# Preply Tutor Profiles Scraper (`crawlerbros/preply-scraper`) Actor

Scrape Preply tutor profiles, search tutors by language, subject, price, and rating. Get name, country, hourly rate, rating, reviews, lessons count, bio, avatar, and more. Supports bulk tutor lookups by URL or ID.

- **URL**: https://apify.com/crawlerbros/preply-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 7 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Preply Tutor Profiles Scraper

Extract comprehensive tutor profiles from [Preply](https://preply.com) — the world's leading online tutoring marketplace with 40,000+ tutors across 50+ languages. Search by language, subject, price, rating, and availability. Perfect for market research, competitive analysis, and education platform insights.

### What You Get

Each tutor profile includes:

| Field | Description |
|---|---|
| `tutorId` | Unique Preply tutor identifier |
| `name` | Tutor's display name |
| `bio` | Tutor's self-description |
| `country` | Tutor's country of origin |
| `nativeLanguage` | Tutor's native language |
| `languagesTaught` | List of languages this tutor teaches |
| `specialties` | Specializations (e.g. Business English, IELTS, Conversation) |
| `hourlyRate` | Price per hour in USD |
| `currency` | Pricing currency |
| `rating` | Average student rating (0–5) |
| `reviewCount` | Total number of student reviews |
| `totalLessons` | Number of lessons completed |
| `responseRate` | Tutor's message response rate (e.g. "98%") |
| `profileUrl` | Direct link to tutor's Preply profile |
| `avatarUrl` | Profile photo URL |
| `videoUrl` | Introduction video URL |
| `isPro` | Whether the tutor is certified/professional |
| `education` | Educational background (detail mode) |
| `certificates` | Teaching certificates (detail mode) |
| `recordType` | Always `"tutor"` |
| `scrapedAt` | ISO 8601 timestamp of extraction |

### Modes

#### `searchTutors` (default)
Search for tutors by language with optional filters. Paginates through Preply's tutor directory.

**Example input:**
```json
{
  "mode": "searchTutors",
  "language": "japanese",
  "minRating": 4.5,
  "maxPrice": 30,
  "maxItems": 50
}
````

#### `getTutor`

Fetch full profiles for specific tutors by their Preply profile URL or numeric ID. Returns detailed data including education history and certificates.

**Example input:**

```json
{
  "mode": "getTutor",
  "startUrls": [
    "https://preply.com/en/tutor/12345",
    "https://preply.com/en/tutor/67890"
  ]
}
```

Or with numeric IDs:

```json
{
  "mode": "getTutor",
  "tutorIds": ["12345", "67890"]
}
```

### Input Reference

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | select | `searchTutors` | Operation mode |
| `language` | select | `spanish` | Language to search tutors for |
| `startUrls` | array | — | Tutor profile URLs (mode=getTutor) |
| `tutorIds` | array | — | Numeric tutor IDs (mode=getTutor) |
| `subject` | string | — | Subject specialty (e.g. "Business English", "IELTS") |
| `sortBy` | select | `popularity` | `popularity` / `rating` / `reviews` / `price_lowest` / `price_highest` |
| `minPrice` | number | — | Minimum hourly rate (USD) |
| `maxPrice` | number | — | Maximum hourly rate (USD) |
| `minRating` | number | — | Minimum average rating (0–5) |
| `nativeOnly` | boolean | `false` | Native speakers only |
| `proOnly` | boolean | `false` | Certified/professional tutors only |
| `tutorCountry` | string | — | ISO country codes to filter by (e.g. `US`, `GB,US,CA`) |
| `availabilityDay` | select | — | Filter by available weekday |
| `useProxy` | boolean | `true` | Use residential proxy (recommended for Cloudflare) |
| `maxItems` | integer | `20` | Maximum profiles to return (1–5000) |

### Supported Languages

English, Spanish, French, German, Italian, Portuguese, Chinese (Mandarin), Japanese, Korean, Russian, Arabic, Dutch, Polish, Turkish, Swedish, Norwegian, Danish, Finnish, Hebrew, Hindi, Ukrainian, Greek, Romanian, Czech, Hungarian, Catalan, Thai, Vietnamese, Indonesian, Malay, Persian (Farsi), Tagalog, Urdu, Bengali, Swahili

### Output Example

```json
{
  "tutorId": "12345",
  "name": "Maria S.",
  "country": "Spain",
  "nativeLanguage": "Spanish",
  "languagesTaught": ["Spanish"],
  "hourlyRate": 15.0,
  "currency": "USD",
  "rating": 4.9,
  "reviewCount": 150,
  "totalLessons": 1200,
  "responseRate": "98%",
  "isPro": true,
  "profileUrl": "https://preply.com/en/tutor/12345",
  "avatarUrl": "https://cdn.preply.com/avatar/12345.jpg",
  "recordType": "tutor",
  "scrapedAt": "2026-05-17T10:00:00+00:00"
}
```

### Use Cases

- **Market Research** — Analyze tutor pricing, ratings, and availability across languages
- **Competitive Analysis** — Compare tutor profiles across online tutoring platforms
- **Education Insights** — Track trends in language learning demand and tutor supply
- **Lead Generation** — Build a dataset of specialized language tutors
- **Academic Research** — Study the gig economy in online education

### Performance

- Processes **10 tutors per page** via Preply's public API
- Supports up to **5,000 tutors** per run
- Automatically handles **Cloudflare protection** via residential proxy rotation
- **Retry logic** on rate limits and server errors

### Proxy Configuration

Preply uses Cloudflare protection. The actor first attempts direct HTTP access (which works for the public ChatGPT OpenAPI endpoint) and automatically falls back to Playwright with a residential proxy if blocked. Enabling `useProxy: true` (default) ensures maximum reliability.

### FAQ

**Q: Does this require a Preply account or API key?**
A: No. The actor uses Preply's public tutor directory and their publicly documented OpenAPI endpoint — no authentication required.

**Q: Can I filter by availability?**
A: Yes — use the `availabilityDay` field to filter by day of the week.

**Q: Why use a proxy?**
A: Preply uses Cloudflare to protect against automated scraping. Residential proxies present requests as regular user traffic, significantly improving success rates.

**Q: How fresh is the data?**
A: Each run fetches live data from Preply at the moment of execution. Tutor profiles, ratings, and prices reflect the current state of Preply's platform.

**Q: How many tutors can I scrape?**
A: Up to 5,000 per run. For larger datasets, run the actor multiple times with different filter settings.

**Q: Are education and certificate details available?**
A: Yes — use `mode=getTutor` with specific tutor IDs/URLs to fetch full profiles including education history and certificates.

# Actor input Schema

## `mode` (type: `string`):

What to fetch: search tutors by language/filters, or retrieve specific tutor profiles by URL or ID.

## `language` (type: `string`):

Language to search tutors for (mode=searchTutors).

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

List of Preply tutor profile URLs (e.g. https://preply.com/en/tutor/12345). Used in mode=getTutor.

## `tutorIds` (type: `array`):

List of Preply tutor numeric IDs. Used in mode=getTutor.

## `subject` (type: `string`):

Optional subject or specialty to filter tutors (e.g. 'Business English', 'IELTS', 'Conversation').

## `sortBy` (type: `string`):

How to order search results.

## `minPrice` (type: `number`):

Only return tutors with hourly rate at or above this value.

## `maxPrice` (type: `number`):

Only return tutors with hourly rate at or below this value.

## `minRating` (type: `number`):

Only return tutors with average rating at or above this value (0–5).

## `nativeOnly` (type: `boolean`):

If true, only return tutors who are native speakers of the selected language.

## `proOnly` (type: `boolean`):

If true, only return certified/professional tutors.

## `tutorCountry` (type: `string`):

Optional comma-separated ISO country codes to filter tutors by their country (e.g. 'US', 'GB,US,CA').

## `availabilityDay` (type: `string`):

Filter tutors available on a specific weekday.

## `useProxy` (type: `boolean`):

Use Apify residential proxy to bypass Cloudflare protection. Recommended.

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

Maximum number of tutor profiles to return.

## Actor input object example

```json
{
  "mode": "searchTutors",
  "language": "spanish",
  "startUrls": [],
  "tutorIds": [],
  "sortBy": "popularity",
  "nativeOnly": false,
  "proOnly": false,
  "availabilityDay": "",
  "useProxy": true,
  "maxItems": 20
}
```

# Actor output Schema

## `tutors` (type: `string`):

Dataset containing all scraped Preply tutor profiles.

# 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 = {
    "mode": "searchTutors",
    "language": "spanish",
    "startUrls": [],
    "tutorIds": [],
    "sortBy": "popularity",
    "nativeOnly": false,
    "proOnly": false,
    "availabilityDay": "",
    "useProxy": true,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/preply-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 = {
    "mode": "searchTutors",
    "language": "spanish",
    "startUrls": [],
    "tutorIds": [],
    "sortBy": "popularity",
    "nativeOnly": False,
    "proOnly": False,
    "availabilityDay": "",
    "useProxy": True,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/preply-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 '{
  "mode": "searchTutors",
  "language": "spanish",
  "startUrls": [],
  "tutorIds": [],
  "sortBy": "popularity",
  "nativeOnly": false,
  "proOnly": false,
  "availabilityDay": "",
  "useProxy": true,
  "maxItems": 20
}' |
apify call crawlerbros/preply-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Preply Tutor Profiles Scraper",
        "description": "Scrape Preply tutor profiles, search tutors by language, subject, price, and rating. Get name, country, hourly rate, rating, reviews, lessons count, bio, avatar, and more. Supports bulk tutor lookups by URL or ID.",
        "version": "1.0",
        "x-build-id": "x0KRhBesXIjL9q3kf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~preply-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-preply-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/crawlerbros~preply-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-preply-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/crawlerbros~preply-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-preply-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "searchTutors",
                            "getTutor"
                        ],
                        "type": "string",
                        "description": "What to fetch: search tutors by language/filters, or retrieve specific tutor profiles by URL or ID.",
                        "default": "searchTutors"
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "english",
                            "spanish",
                            "french",
                            "german",
                            "italian",
                            "portuguese",
                            "chinese",
                            "japanese",
                            "korean",
                            "russian",
                            "arabic",
                            "dutch",
                            "polish",
                            "turkish",
                            "swedish",
                            "norwegian",
                            "danish",
                            "finnish",
                            "hebrew",
                            "hindi",
                            "ukrainian",
                            "greek",
                            "romanian",
                            "czech",
                            "hungarian",
                            "catalan",
                            "thai",
                            "vietnamese",
                            "indonesian",
                            "malay",
                            "persian",
                            "tagalog",
                            "urdu",
                            "bengali",
                            "swahili"
                        ],
                        "type": "string",
                        "description": "Language to search tutors for (mode=searchTutors).",
                        "default": "spanish"
                    },
                    "startUrls": {
                        "title": "Tutor URLs (mode=getTutor)",
                        "type": "array",
                        "description": "List of Preply tutor profile URLs (e.g. https://preply.com/en/tutor/12345). Used in mode=getTutor.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "tutorIds": {
                        "title": "Tutor IDs (mode=getTutor)",
                        "type": "array",
                        "description": "List of Preply tutor numeric IDs. Used in mode=getTutor.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "subject": {
                        "title": "Subject / Specialty",
                        "type": "string",
                        "description": "Optional subject or specialty to filter tutors (e.g. 'Business English', 'IELTS', 'Conversation')."
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "popularity",
                            "rating",
                            "reviews",
                            "price_lowest",
                            "price_highest"
                        ],
                        "type": "string",
                        "description": "How to order search results.",
                        "default": "popularity"
                    },
                    "minPrice": {
                        "title": "Min hourly price (USD)",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "number",
                        "description": "Only return tutors with hourly rate at or above this value."
                    },
                    "maxPrice": {
                        "title": "Max hourly price (USD)",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "number",
                        "description": "Only return tutors with hourly rate at or below this value."
                    },
                    "minRating": {
                        "title": "Min rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Only return tutors with average rating at or above this value (0–5)."
                    },
                    "nativeOnly": {
                        "title": "Native speakers only",
                        "type": "boolean",
                        "description": "If true, only return tutors who are native speakers of the selected language.",
                        "default": false
                    },
                    "proOnly": {
                        "title": "Professional tutors only",
                        "type": "boolean",
                        "description": "If true, only return certified/professional tutors.",
                        "default": false
                    },
                    "tutorCountry": {
                        "title": "Tutor country filter",
                        "type": "string",
                        "description": "Optional comma-separated ISO country codes to filter tutors by their country (e.g. 'US', 'GB,US,CA')."
                    },
                    "availabilityDay": {
                        "title": "Availability day",
                        "enum": [
                            "",
                            "sun",
                            "mon",
                            "tue",
                            "wed",
                            "thu",
                            "fri",
                            "sat"
                        ],
                        "type": "string",
                        "description": "Filter tutors available on a specific weekday.",
                        "default": ""
                    },
                    "useProxy": {
                        "title": "Use residential proxy",
                        "type": "boolean",
                        "description": "Use Apify residential proxy to bypass Cloudflare protection. Recommended.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of tutor profiles to return.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
