# SeLoger Property Listings Scraper (`automation-lab/seloger-property-listings-scraper`) Actor

Extract SeLoger listings with prices, locations, agencies, images, descriptions, and URLs for French real-estate market monitoring.

- **URL**: https://apify.com/automation-lab/seloger-property-listings-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Real estate
- **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.
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

## SeLoger Property Listings Scraper

Export structured property listings from public SeLoger search pages.

Use this actor to collect rental and sale inventory from SeLoger result URLs and turn each listing card into a clean dataset with price, area, rooms, location, agency, images, description, and the listing URL.

### What does SeLoger Property Listings Scraper do?

SeLoger Property Listings Scraper reads public SeLoger search/category result pages and extracts the embedded listing data that powers the search experience.

It is built for repeatable real-estate market monitoring workflows:

- 🏠 Collect property listings from SeLoger city or neighborhood searches
- 💶 Export asking prices, price periods, and price per square meter
- 📍 Capture city, postal code, district, and agency information
- 🖼️ Save listing image and floor-plan URLs
- 🔁 Run the same searches regularly to monitor inventory changes

### Who is it for?

This scraper is useful for teams that need French property market data without manually browsing SeLoger.

Typical users include:

- Real-estate analysts tracking local asking prices
- Proptech teams building market dashboards
- Brokerages monitoring competitor inventory
- Investors watching rental supply and sale listings
- Data teams enriching internal property databases
- Journalists and researchers studying French housing markets

### Why use this actor?

SeLoger pages contain rich listing data, but copying it manually is slow and error-prone.

This actor gives you:

- Clean JSON/CSV/Excel-ready rows
- Stable field names for downstream pipelines
- Configurable result limits
- Multiple start URLs in one run
- Optional Apify Proxy support if your run environment needs it
- Pay-per-event pricing so small tests stay inexpensive

### How it works

The actor uses an HTTP-first Cheerio approach.

Public SeLoger result pages include embedded search-result JSON in the page HTML. The actor fetches each start URL, parses the embedded `__UFRN_FETCHER__` data, maps listing IDs to normalized records, and stores those records in the default Apify dataset.

### Supported pages

Use public SeLoger search or category URLs such as:

- `https://www.seloger.com/immobilier/locations/immo-paris-75/`
- `https://www.seloger.com/immobilier/locations/immo-lyon-69/`
- `https://www.seloger.com/immobilier/locations/immo-marseille-13/`
- Other public SeLoger search result pages that expose listing data in the initial HTML

### Input

The actor accepts a small set of practical controls.

| Field | Type | Description |
| --- | --- | --- |
| `startUrls` | array | SeLoger search/category URLs to scrape |
| `maxItems` | integer | Maximum listing rows to save across all URLs |
| `includeSuggestedListings` | boolean | Include suggested/promoted listings when present |
| `maxImages` | integer | Maximum image URLs saved per listing |
| `useApifyProxy` | boolean | Enable Apify Proxy if direct access is blocked |
| `proxyCountryCode` | string | Optional proxy country code, for example `FR` |

### Example input

```json
{
  "startUrls": [
    { "url": "https://www.seloger.com/immobilier/locations/immo-paris-75/" },
    { "url": "https://www.seloger.com/immobilier/locations/immo-lyon-69/" }
  ],
  "maxItems": 60,
  "includeSuggestedListings": true,
  "maxImages": 5,
  "useApifyProxy": false
}
````

### Output

Each dataset item represents one SeLoger property listing.

| Field | Description |
| --- | --- |
| `listingId` | SeLoger listing identifier |
| `legacyId` | Legacy SeLoger listing ID when available |
| `title` | Listing title |
| `enrichedTitle` | SeLoger enriched title/category |
| `transactionType` | Rent/sale distribution type from SeLoger data |
| `propertyType` | Property type label |
| `price` | Numeric asking price |
| `priceText` | Formatted price text |
| `pricePeriod` | Price period such as `/mois` |
| `pricePerSqm` | Calculated price per square meter |
| `areaSqm` | Living area in square meters |
| `rooms` | Number of rooms |
| `bedrooms` | Number of bedrooms |
| `floor` | Floor text when present |
| `keyFacts` | SeLoger listing key facts |
| `city` | City or arrondissement |
| `zipCode` | Postal code |
| `district` | District/neighborhood |
| `address` | Agency address when available |
| `agencyName` | Agency or intermediary name |
| `agencyType` | Agency/private owner type |
| `agencyProfileUrl` | SeLoger agency profile URL |
| `phoneNumbers` | Visible phone numbers when exposed in page data |
| `listingUrl` | Canonical listing URL |
| `images` | Listing image URLs |
| `floorPlans` | Floor-plan image URLs |
| `description` | Listing description snippet |
| `energyClass` | Energy class |
| `isNew` | Whether SeLoger marks the listing as new |
| `isExclusive` | Whether SeLoger marks the listing as exclusive |
| `has3DVisit` | Whether a 3D visit is available |
| `createdAt` | SeLoger creation timestamp |
| `updatedAt` | SeLoger update timestamp |
| `sourceUrl` | Search URL where the listing was found |
| `scrapedAt` | Actor scrape timestamp |

### Example output

```json
{
  "listingId": "267XBCWFAQSS",
  "legacyId": "274524709",
  "title": "Appartement à louer",
  "transactionType": "RENT",
  "propertyType": "Appartement",
  "price": 1235.79,
  "priceText": "1 236 €/mois",
  "areaSqm": 35.22,
  "rooms": 2,
  "bedrooms": 1,
  "city": "Paris 20ème arrondissement",
  "zipCode": "75020",
  "agencyName": "OQORO",
  "listingUrl": "https://www.seloger.com/annonces/...",
  "sourceUrl": "https://www.seloger.com/immobilier/locations/immo-paris-75/",
  "scrapedAt": "2026-07-10T04:34:34.587Z"
}
```

### How much does it cost to scrape SeLoger property listings?

The actor uses pay-per-event pricing.

- Start event: $0.005 per run
- Item event: tiered per saved property listing (BRONZE $0.000028429; FREE $0.000032693; SILVER $0.000022175; GOLD $0.000017057; PLATINUM $0.000011372; DIAMOND $0.00001)

Keep `maxItems` low for test runs and increase it when you are satisfied with the output.

### Tips for best results

- Start with one or two city search URLs.
- Use `maxItems` around 20-60 for validation runs.
- Add more start URLs to collect more than one SeLoger result page worth of data.
- Keep `maxImages` modest if you only need analytics fields.
- Enable Apify Proxy only if direct access is blocked in your environment.

### Common workflows

#### Track Paris rental inventory

Run a Paris rental URL every day and compare `listingId`, `price`, and `updatedAt` across datasets.

#### Compare city markets

Provide several city URLs, such as Paris, Lyon, Marseille, Toulouse, and Bordeaux, then group output by `city` and `zipCode`.

#### Monitor agency listings

Filter results by `agencyName` or `agencyProfileUrl` in your downstream database.

#### Build price dashboards

Use `price`, `areaSqm`, `pricePerSqm`, `rooms`, `bedrooms`, and `district` to build market snapshots.

### Integrations

Export results to:

- Google Sheets for manual review
- BigQuery or Snowflake for analytics
- Airtable for editorial workflows
- Webhooks for listing-change alerts
- A CRM or internal brokerage database

### API usage

You can run the actor from the Apify API.

#### Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/seloger-property-listings-scraper').call({
  startUrls: [{ url: 'https://www.seloger.com/immobilier/locations/immo-paris-75/' }],
  maxItems: 50,
});

console.log(`Dataset: https://api.apify.com/v2/datasets/${run.defaultDatasetId}/items`);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/seloger-property-listings-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.seloger.com/immobilier/locations/immo-paris-75/'}],
    'maxItems': 50,
})

print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~seloger-property-listings-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.seloger.com/immobilier/locations/immo-paris-75/"}],"maxItems":50}'
```

### MCP integration

Use the actor from MCP-compatible tools through Apify MCP.

Claude Code CLI setup:

```bash
claude mcp add apify https://mcp.apify.com/?tools=automation-lab/seloger-property-listings-scraper
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=automation-lab/seloger-property-listings-scraper"
    }
  }
}
```

Direct MCP tool URL:

```text
https://mcp.apify.com/?tools=automation-lab/seloger-property-listings-scraper
```

Example prompts:

- "Scrape 50 SeLoger rental listings in Paris and summarize median price per sqm."
- "Collect SeLoger listings from Paris and Lyon and compare bedroom counts."
- "Export SeLoger listing URLs and agency names for this search."

### Data quality notes

The actor extracts fields exposed in SeLoger's public search-page data. Some fields are optional and depend on the listing, agency, and SeLoger page variant.

Examples:

- Some listings have no visible phone number.
- Some listings have no floor plan.
- Descriptions may be snippets rather than full detail-page descriptions.
- Search pages usually expose one page of listing cards; use multiple URLs for larger collections.

### Troubleshooting

#### I got no results

Check that your `startUrls` are public SeLoger search result pages. Detail pages or unsupported URLs may not include the embedded result dataset.

#### I see blocked or error pages

Try again with fewer URLs. If your run environment is blocked, enable `useApifyProxy` and set `proxyCountryCode` to `FR`.

#### I need more than one page of results

Add multiple SeLoger category, city, arrondissement, or neighborhood URLs. This MVP extracts the result data present in the initial HTML for each supplied URL.

### Legality

This actor extracts publicly available information from SeLoger pages. You are responsible for ensuring your use of the data complies with applicable laws, SeLoger's terms, and privacy requirements. Avoid collecting or using personal data in ways that are not legally permitted.

### Related scrapers

You may also find these automation-lab actors useful:

- https://apify.com/automation-lab/zillow-scraper
- https://apify.com/automation-lab/realtor-ca-property-listings-scraper
- https://apify.com/automation-lab/homes-co-nz-property-search-scraper

### Limitations

- The actor does not log into SeLoger.
- It does not bypass CAPTCHAs.
- It extracts public search-page data, not every field from detail pages.
- It depends on SeLoger's current embedded HTML data structure.

### Changelog

See `.actor/CHANGELOG.md` for release notes.

# Actor input Schema

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

Public SeLoger search/category result URLs, such as Paris rentals or city/neighborhood pages.

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

Maximum number of property listing records to save across all start URLs.

## `includeSuggestedListings` (type: `boolean`):

Also include SeLoger suggested/promoted listings when they are present in the search page data.

## `maxImages` (type: `integer`):

Limit image URLs stored for each property listing. Set to 0 to omit images.

## `useApifyProxy` (type: `boolean`):

Enable only if direct access from your run is blocked. The default direct HTTP mode is cheaper and worked during development.

## `proxyCountryCode` (type: `string`):

Optional ISO country code for Apify Proxy, for example FR. Used only when Apify Proxy is enabled.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.seloger.com/immobilier/locations/immo-paris-75/"
    },
    {
      "url": "https://www.seloger.com/recherche/location/immobilier/paris-75000/paris-16eme-arrondissement-75016/ad09fr41"
    }
  ],
  "maxItems": 20,
  "includeSuggestedListings": false,
  "maxImages": 10,
  "useApifyProxy": false,
  "proxyCountryCode": "FR"
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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": [
        {
            "url": "https://www.seloger.com/immobilier/locations/immo-paris-75/"
        },
        {
            "url": "https://www.seloger.com/recherche/location/immobilier/paris-75000/paris-16eme-arrondissement-75016/ad09fr41"
        }
    ],
    "maxItems": 20,
    "maxImages": 10,
    "proxyCountryCode": "FR"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/seloger-property-listings-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": [
        { "url": "https://www.seloger.com/immobilier/locations/immo-paris-75/" },
        { "url": "https://www.seloger.com/recherche/location/immobilier/paris-75000/paris-16eme-arrondissement-75016/ad09fr41" },
    ],
    "maxItems": 20,
    "maxImages": 10,
    "proxyCountryCode": "FR",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/seloger-property-listings-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": [
    {
      "url": "https://www.seloger.com/immobilier/locations/immo-paris-75/"
    },
    {
      "url": "https://www.seloger.com/recherche/location/immobilier/paris-75000/paris-16eme-arrondissement-75016/ad09fr41"
    }
  ],
  "maxItems": 20,
  "maxImages": 10,
  "proxyCountryCode": "FR"
}' |
apify call automation-lab/seloger-property-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SeLoger Property Listings Scraper",
        "description": "Extract SeLoger listings with prices, locations, agencies, images, descriptions, and URLs for French real-estate market monitoring.",
        "version": "0.1",
        "x-build-id": "YYqhxMkMtssDgpyDv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~seloger-property-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-seloger-property-listings-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/automation-lab~seloger-property-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-seloger-property-listings-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/automation-lab~seloger-property-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-seloger-property-listings-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": "SeLoger search URLs",
                        "type": "array",
                        "description": "Public SeLoger search/category result URLs, such as Paris rentals or city/neighborhood pages.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of property listing records to save across all start URLs.",
                        "default": 20
                    },
                    "includeSuggestedListings": {
                        "title": "Include suggested listings",
                        "type": "boolean",
                        "description": "Also include SeLoger suggested/promoted listings when they are present in the search page data.",
                        "default": false
                    },
                    "maxImages": {
                        "title": "Maximum images per listing",
                        "minimum": 0,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Limit image URLs stored for each property listing. Set to 0 to omit images.",
                        "default": 10
                    },
                    "useApifyProxy": {
                        "title": "Use Apify Proxy",
                        "type": "boolean",
                        "description": "Enable only if direct access from your run is blocked. The default direct HTTP mode is cheaper and worked during development.",
                        "default": false
                    },
                    "proxyCountryCode": {
                        "title": "Proxy country code",
                        "type": "string",
                        "description": "Optional ISO country code for Apify Proxy, for example FR. Used only when Apify Proxy is enabled.",
                        "default": "FR"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
