# OLX Portugal Classifieds Scraper (`automation-lab/olx-portugal-classifieds-scraper`) Actor

Scrape public OLX.pt classifieds from category/search pages. Export prices, locations, images, seller details, and listing URLs.

- **URL**: https://apify.com/automation-lab/olx-portugal-classifieds-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## OLX Portugal Classifieds Scraper

Scrape public OLX.pt classified listings from category pages, search result pages, and keyword searches. Export listing URLs, titles, prices, locations, dates, images, source pages, and optional detail-page enrichment in a clean dataset ready for spreadsheets, BI tools, CRMs, or automations.

### What does OLX Portugal Classifieds Scraper do?

OLX Portugal Classifieds Scraper collects public listing data from [OLX.pt](https://www.olx.pt), one of Portugal's most active classified marketplaces.

It can scrape:

- 🏠 Real estate category pages
- 🚗 Car and vehicle listings
- 📱 Electronics and consumer goods searches
- 🧰 Services and local offers
- 🔎 Any public OLX.pt search URL you provide

The actor starts from OLX category URLs or a keyword search, follows pagination, extracts listing cards, and saves structured results to the default Apify dataset.

### Who is it for?

This scraper is useful for teams that need repeatable OLX Portugal marketplace data.

- 🏘️ **Real estate analysts** monitoring rental and sale supply in Portuguese cities
- 🚙 **Vehicle price researchers** tracking used car offers by region
- 🛒 **Marketplace intelligence teams** comparing second-hand prices and availability
- 📈 **Growth and lead-generation teams** finding public seller opportunities
- 🧪 **Data analysts** building market snapshots from public classified listings
- 🤖 **Automation builders** feeding OLX listings into alerts, CRMs, or dashboards

### Why use this OLX.pt scraper?

Manual OLX research is slow and difficult to repeat. This actor gives you structured data with consistent fields and pagination controls.

Benefits:

- ⚡ Fast HTTP-based scraping, no browser required for the main listing mode
- 🧾 Clean JSON output with price, currency, location, images, and page metadata
- 🔁 Repeatable runs for monitoring the same categories or searches
- 🎯 Supports both ready-made OLX URLs and keyword searches
- 🧩 Works with Apify API, webhooks, datasets, integrations, and MCP tools

### What data can you extract from OLX Portugal?

The default dataset contains one row per OLX listing.

| Field | Description |
| --- | --- |
| `listingId` | OLX card ID or ID parsed from the listing URL |
| `url` | Canonical OLX listing URL |
| `title` | Public listing title |
| `priceText` | Price as displayed on OLX |
| `price` | Parsed numeric price when available |
| `currency` | Currency code, usually `EUR` |
| `location` | Public location text from the card |
| `postedAt` | Posted, updated, or promoted date text |
| `categoryPath` | Category path supplied in input |
| `imageUrl` | Main listing image URL |
| `imageUrls` | Image URLs parsed from the listing card |
| `sellerName` | Public seller name when detail mode finds it |
| `sellerType` | Public seller type when visible |
| `description` | Detail-page description when detail mode is enabled |
| `attributes` | Visible detail-page parameters when found |
| `isPromoted` | Whether the card appears promoted/top-listed |
| `sourceUrl` | OLX page where the listing was found |
| `page` | Search result page number |
| `scrapedAt` | ISO timestamp of extraction |

### How much does it cost to scrape OLX Portugal classifieds?

This actor uses pay-per-event pricing:

- Run start: **$0.005** per run.
- Per listing: **$0.000034986** on Free, **$0.000030423** on Starter/BRONZE, with lower rates on higher Apify plans.

| Plan tier | Price per listing | Approx. 1,000 listings |
| --- | ---: | ---: |
| Free | $0.000034986 | $0.0350 |
| Starter / BRONZE | $0.000030423 | $0.0304 |
| Scale / SILVER | $0.00002373 | $0.0237 |
| Business / GOLD | $0.000018254 | $0.0183 |

You control cost with `maxResults` and `maxPages`. For a first run, keep the prefilled limit around 20 listings. Larger monitoring jobs can increase the limit after you confirm the output fits your workflow.

### How to scrape OLX.pt listings

1. Open the actor on Apify.
2. Paste one or more OLX.pt category or search URLs into **OLX.pt category or search URLs**.
3. Set **Maximum listings**.
4. Keep **Open detail pages** disabled for the fastest card-only run.
5. Enable detail pages only if you need descriptions, seller names, or attributes.
6. Click **Start**.
7. Download the dataset as JSON, CSV, Excel, XML, RSS, or HTML.

### Input options

#### OLX.pt category or search URLs

Use this when you already have OLX result pages, for example:

```text
https://www.olx.pt/imoveis/
https://www.olx.pt/carros-motos-e-barcos/
https://www.olx.pt/ads/q-iphone/
````

#### Search keyword

If `startUrls` is empty, the actor can build an OLX keyword URL from `searchQuery`, such as:

```text
iphone
apartamento lisboa
bicicleta estrada
```

#### Fallback category path

If both `startUrls` and `searchQuery` are empty, the actor uses `categoryPath`, defaulting to `/imoveis/`.

#### Maximum listings

The global cap for saved rows. The actor stops as soon as this number is reached.

#### Open detail pages

When enabled, the actor opens each listing URL and tries to extract description, seller name/type, and public attributes.

Detail mode is slower because it makes one extra request per listing.

### Example input

```json
{
  "startUrls": [
    { "url": "https://www.olx.pt/imoveis/" }
  ],
  "maxResults": 30,
  "includeDetails": false,
  "maxPages": 3,
  "maxRequestRetries": 3
}
```

### Example output

```json
{
  "listingId": "669245007",
  "url": "https://www.olx.pt/d/anuncio/quarto-da-natureza-IDJi5cj.html",
  "title": "Quarto da Natureza",
  "priceText": "350 €",
  "price": 350,
  "currency": "EUR",
  "location": "Carregado E Cadafais",
  "postedAt": "Para o topo a 14 de maio de 2026",
  "imageUrl": "https://ireland.apollo.olxcdn.com/.../image;s=216x152;q=50",
  "isPromoted": true,
  "sourceUrl": "https://www.olx.pt/imoveis/",
  "page": 1,
  "scrapedAt": "2026-05-17T08:00:00.000Z"
}
```

### Tips for better OLX scraping

- 🎯 Use specific category URLs when possible.
- 🔎 Use keyword search for product monitoring.
- 📉 Start with a low `maxResults` value to verify your query.
- ⚡ Leave detail pages off for fast list monitoring.
- 🧾 Turn detail pages on only when descriptions or seller fields matter.
- 🔁 Schedule the actor to monitor categories over time.
- 📍 Use separate runs for different cities or categories to keep analysis clean.

### Integrations and workflows

You can connect this actor to common Apify workflows:

- Send new OLX listings to Google Sheets.
- Push real estate listings to Airtable for review.
- Trigger Slack alerts when new listings match a query.
- Export daily vehicle prices to a data warehouse.
- Feed marketplace intelligence dashboards with fresh CSV files.
- Use webhooks to launch downstream enrichment actors.

### API usage: using the OLX scraper with the Apify API

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/olx-portugal-classifieds-scraper').call({
  startUrls: [{ url: 'https://www.olx.pt/imoveis/' }],
  maxResults: 30,
  includeDetails: false
});

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

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/olx-portugal-classifieds-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.olx.pt/imoveis/'}],
    'maxResults': 30,
    'includeDetails': False,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~olx-portugal-classifieds-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.olx.pt/imoveis/"}],"maxResults":30,"includeDetails":false}'
```

### Use with AI agents via MCP

OLX Portugal Classifieds Scraper is available as a tool for AI assistants that support the Model Context Protocol (MCP).

Setup for Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com"
```

Setup for Claude Desktop, Cursor, or VS Code:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com"
    }
  }
}
```

Your AI assistant will authenticate with your Apify account on first use. You can then reference `automation-lab/olx-portugal-classifieds-scraper` in prompts.

Example prompts:

- "Use automation-lab/olx-portugal-classifieds-scraper to collect 50 OLX.pt apartment listings in Lisbon and summarize prices."
- "Run the OLX Portugal scraper for iPhone listings and identify the cheapest offers."
- "Scrape OLX Portugal real estate listings and create a CSV grouped by location."

### Legality: is it legal to scrape OLX Portugal?

This actor extracts publicly available listing information from OLX.pt pages. You are responsible for using the output lawfully and respecting applicable rules, privacy requirements, and platform terms.

Do not use this actor to scrape private account data, bypass login protections, spam sellers, or make automated decisions that require legal review.

### Limitations

- OLX page markup can change, so selectors may need maintenance over time.
- Some fields are only available on detail pages.
- Seller phone numbers and private contact details are not collected.
- Search availability depends on what OLX publicly shows for your query.
- Very broad searches may require more pages and a higher `maxResults` limit.

### FAQ and troubleshooting

**How fast is the OLX Portugal scraper?**

Card-only HTTP runs usually finish quickly because no browser is opened. A 120-listing cloud test finished in under 10 seconds of actor runtime.

**How much does it cost to scrape OLX.pt?**

The actor charges a small run-start fee plus a per-listing event. Use `maxResults` to cap the total cost of each run.

**Does OLX Portugal have an official API?**

This actor is designed for public OLX.pt pages when you need export-ready listing data and Apify integrations without building your own scraper.

**Why did I get fewer listings than requested?**

The selected OLX category or search may have fewer visible results, repeated promoted cards, or pagination limits. Try a broader query or increase `maxPages`.

**Why are descriptions empty?**

Descriptions require `includeDetails: true`. In card-only mode, the actor does not open listing pages.

**Why is price missing?**

Some OLX ads show negotiable, free, exchange, or contact-only pricing. In those cases `priceText` may be present while numeric `price` is empty.

### Related scrapers

Explore other Automation Lab actors for marketplace, ecommerce, real estate, and lead-generation workflows:

- https://apify.com/automation-lab/google-maps-lead-finder
- https://apify.com/automation-lab/zillow-scraper
- https://apify.com/automation-lab/booking-scraper
- https://apify.com/automation-lab/trustpilot-scraper

### Changelog

#### 0.1

Initial version with OLX.pt category/search scraping, pagination, listing-card extraction, optional detail enrichment, and structured dataset output.

# Actor input Schema

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

Optional OLX Portugal category/search/listing-result URLs to scrape. If empty, the actor uses the search query or default category path.

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

Keyword to search on OLX.pt, for example 'iphone', 'apartamento lisboa', or 'bicicleta'. Used when start URLs are empty.

## `categoryPath` (type: `string`):

OLX.pt path to scrape when start URLs and search keyword are empty, for example /imoveis/ or /carros-motos-e-barcos/.

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

Maximum number of OLX listings to save.

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

Open each listing page to extract description, seller name/type, and visible attributes when available. This is slower than card-only mode.

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

Safety limit for pagination per start URL.

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

Retry attempts for temporary OLX/network failures.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.olx.pt/imoveis/"
    }
  ],
  "searchQuery": "iphone",
  "categoryPath": "/imoveis/",
  "maxResults": 20,
  "includeDetails": false,
  "maxPages": 3,
  "maxRequestRetries": 3
}
```

# 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.olx.pt/imoveis/"
        }
    ],
    "searchQuery": "iphone",
    "categoryPath": "/imoveis/",
    "maxResults": 20,
    "includeDetails": false,
    "maxPages": 3,
    "maxRequestRetries": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/olx-portugal-classifieds-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.olx.pt/imoveis/" }],
    "searchQuery": "iphone",
    "categoryPath": "/imoveis/",
    "maxResults": 20,
    "includeDetails": False,
    "maxPages": 3,
    "maxRequestRetries": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/olx-portugal-classifieds-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.olx.pt/imoveis/"
    }
  ],
  "searchQuery": "iphone",
  "categoryPath": "/imoveis/",
  "maxResults": 20,
  "includeDetails": false,
  "maxPages": 3,
  "maxRequestRetries": 3
}' |
apify call automation-lab/olx-portugal-classifieds-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "OLX Portugal Classifieds Scraper",
        "description": "Scrape public OLX.pt classifieds from category/search pages. Export prices, locations, images, seller details, and listing URLs.",
        "version": "0.1",
        "x-build-id": "GbbYW8Af4CFJKVqJ4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~olx-portugal-classifieds-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-olx-portugal-classifieds-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~olx-portugal-classifieds-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-olx-portugal-classifieds-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~olx-portugal-classifieds-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-olx-portugal-classifieds-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": {
                    "startUrls": {
                        "title": "OLX.pt category or search URLs",
                        "type": "array",
                        "description": "Optional OLX Portugal category/search/listing-result URLs to scrape. If empty, the actor uses the search query or default category path.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchQuery": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "Keyword to search on OLX.pt, for example 'iphone', 'apartamento lisboa', or 'bicicleta'. Used when start URLs are empty."
                    },
                    "categoryPath": {
                        "title": "Fallback category path",
                        "type": "string",
                        "description": "OLX.pt path to scrape when start URLs and search keyword are empty, for example /imoveis/ or /carros-motos-e-barcos/.",
                        "default": "/imoveis/"
                    },
                    "maxResults": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of OLX listings to save.",
                        "default": 50
                    },
                    "includeDetails": {
                        "title": "Open detail pages",
                        "type": "boolean",
                        "description": "Open each listing page to extract description, seller name/type, and visible attributes when available. This is slower than card-only mode.",
                        "default": false
                    },
                    "maxPages": {
                        "title": "Maximum pages per source URL",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Safety limit for pagination per start URL.",
                        "default": 20
                    },
                    "maxRequestRetries": {
                        "title": "Maximum request retries",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Retry attempts for temporary OLX/network failures.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
