# Preply Tutor Scraper (`epicscrapers/preply-tutor-scraper`) Actor

Extract tutor profiles, prices, ratings, and availability data from Preply.com. Filter by subject, country, native speaker status, availability, and more. Perfect for market research, competitor analysis, and lead generation in online tutoring.

- **URL**: https://apify.com/epicscrapers/preply-tutor-scraper.md
- **Developed by:** [Epic Scrapers](https://apify.com/epicscrapers) (community)
- **Categories:** Automation, Developer tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Preply Tutor Scraper

Extract detailed tutor profiles from **Preply.com** — including ratings, pricing, languages, qualifications, availability, and more. Whether you're researching the tutoring market, analyzing competitor supply, or finding the best tutors for a specific need, this Actor gives you structured data on thousands of Preply tutors in minutes.

---

### What can Preply Tutor Scraper do?

- **Search tutors by subject** — English, Spanish, French, German, Math, Chinese, and dozens more
- **Filter by location** — Online tutors only, or tutors in a specific city
- **Refine by criteria** — Price range, country of birth, native speakers, Super Tutors, certified professionals
- **Sort results** — By price (lowest/highest), popularity, rating, number of reviews, or relevance
- **Free-text search** — Find tutors matching specific keywords like "business English" or "exam preparation"
- **Filter by availability** — Days of the week and time slots when tutors are available
- **Filter by specialties** — IELTS prep, conversational practice, TOEFL, business English, children's English, and more
- **Get comprehensive profiles** — Each tutor record includes their bio, languages spoken, experience, and teaching stats

---

### What data can you extract from Preply?

| Field | Description |
|---|---|
| Tutor name | Full name and first name |
| Headline | Short teaching tagline (e.g., "Certified ESL teacher with 5 years experience") |
| Short bio | Full biography text |
| Price per hour | Price in local currency with currency code and symbol |
| Rating | Average score out of 5.0 |
| Review count | Total number of student reviews |
| Total lessons | Total lessons taught on Preply |
| Languages | List of languages spoken with CEFR proficiency levels |
| Country of birth | Country name and flag |
| Online status | Whether the tutor is currently online |
| Badges | Super Tutor, Professional/Certified, Verified, Popular |
| Years of experience | Total teaching experience in years |
| Active students | Current number of active students |
| Video intro | YouTube intro video URL |
| Avatar | Profile photo URL |
| Subject specialties | Subjects the tutor teaches |
| Availability | Nearest available time slots for booking |
| Instant booking | Whether the tutor accepts instant bookings |

---

### How to scrape Preply with Preply Tutor Scraper

1. **Open the Actor** in the [Apify Console](https://console.apify.com).
2. **Enter a subject** — type the subject you want to search (e.g., `english`, `spanish`, `french`, `math`).
3. **Configure filters** — optionally set a city, price range, country of birth, sort order, or any of the advanced filters.
4. **Click Run** — the Actor will fetch tutor profiles and save them to the dataset.
5. **Download your data** — export the results as JSON, CSV, Excel, or HTML from the Dataset tab.

That's it. No coding required, no browser setup, no complex configuration.

---

### Input

All inputs are configured in the **Input** tab before running the Actor. The only required field is the **subject** — everything else is optional and has sensible defaults.

| Input | What it does |
|---|---|
| Subject | The subject to search for (e.g., `english`, `spanish`, `math`) |
| City | Filter tutors by city, or use `online` for all online tutors |
| Max Pages | How many search result pages to scrape (each page has ~20 tutors) |
| Max Tutors | Stop after scraping this many tutors (leave 0 for unlimited) |
| Sort Order | Sort by price, popularity, rating, or relevance |
| Search Text | Free-text search within tutor profiles |
| Price Range | Filter by hourly rate (e.g., `10-30` for tutors between $10 and $30) |
| Country of Birth | Only show tutors from a specific country |
| Native Speaker | Only show native speakers |
| Super Tutor | Only show tutors with Super Tutor status |
| Professional Tutor | Only show certified/professional tutors |
| Availability Times | Filter by time slots when tutors are available |
| Availability Days | Filter by days of the week |
| Specialties | Filter by teaching specialties (IELTS, business, TOEFL, etc.) |
| Target Language | Filter tutors who speak a specific language |

---

### Output

Each scraped tutor profile is stored as one item in the dataset. Here's an example of what a single record looks like:

```json
{
  "id": 274653,
  "videoIntro": "https://youtu.be/-2N1ZQARUp0",
  "videoThumbnailUrl": null,
  "publicUrl": "https://preply.com/en/tutor/274653",
  "countryOfBirth": {
    "name": "United Kingdom",
    "flagSvg": "https://static.preply.com/groot/country_flags/4x3/gb.svg",
    "__typename": "CountryOfBirthObjectES"
  },
  "headline": "Native qualified English teacher with international experience",
  "alternativeTranslatedContent": null,
  "averageScore": 4.99,
  "numberReviews": 39,
  "totalLessons": 4269,
  "pricePerHourUsd": null,
  "price": {
    "value": "42.50",
    "currency": {
      "id": null,
      "code": "EUR",
      "symbol": "€",
      "factor": 0.85,
      "__typename": "CurrencyNode"
    },
    "__typename": "PriceObject"
  },
  "canBookInstantly": true,
  "isVisibleOnSearch": true,
  "isSuperTutor": true,
  "isSuperTutorLowerCr": true,
  "isProfessionalTutor": true,
  "recentLeadsAmount": 12,
  "user": {
    "id": 1261157,
    "fullName": "Sarah D.",
    "firstName": "Sarah",
    "profile": {
      "id": 1260781,
      "avatarUrlHttps": "https://avatars.preply.com/i/logos/i/logos/avatar_uxjpn4e5i1.jpg",
      "onlineStatus": {
        "isOnline": false,
        "__typename": "OnlineStatusObject"
      },
      "__typename": "UserProfileNodeES"
    },
    "__typename": "UserNodeES"
  },
  "tutorSubjects": [
    {
      "subject": {
        "alias": "english",
        "languageCode": "en",
        "__typename": "SubjectNodeES"
      },
      "__typename": "TutorSubjectNodeES"
    }
  ],
  "shortBio": "Hi! I'm Sarah, a qualified English teacher from Leicester, UK.\nI am very patient, thorough and encourage correct pronunciation. . but above all, I ensure that in every lesson we will incorporate real conversation, interesting topics and memorable discussions to achieve a genuine fluency.\n",
  "lessonsBookedLast48h": 10,
  "verifiedTutor": true,
  "yearsOfExperience": 7,
  "activeStudentsCount": 19,
  "isFavorite": false,
  "multiLanguages": [
    {
      "name": "Spanish",
      "level": null,
      "levelCode": "B1",
      "language": "es",
      "__typename": "TutorMultiLanguageNodeES"
    },
    {
      "name": "Italian",
      "level": null,
      "levelCode": "B2",
      "language": "it",
      "__typename": "TutorMultiLanguageNodeES"
    },
    {
      "name": "English",
      "level": null,
      "levelCode": "Native",
      "language": "en",
      "__typename": "TutorMultiLanguageNodeES"
    }
  ],
  "attributes": [
    {
      "name": "IS_SUPER_TUTOR",
      "title": "Super Tutor",
      "description": "Reliable and motivating",
      "__typename": "TutorAttributeNode"
    },
    {
      "name": "IS_CERTIFIED_TUTOR",
      "title": "Certified",
      "description": "Professional language tutor",
      "__typename": "TutorAttributeNode"
    },
    {
      "name": "IS_POPULAR_TUTOR_LESSONS",
      "title": "Popular",
      "description": "5+ lessons booked recently",
      "__typename": "TutorAttributeNode"
    },
    {
      "name": "HAS_CONSECUTIVE_FIVE_RATED_LESSONS",
      "title": "Active and engaged",
      "description": "All recent lessons rated 5 stars",
      "__typename": "TutorAttributeNode"
    }
  ],
  "nearestAvailableTimeslots": [],
  "tutorTaughtLearnersWithGoals": null,
  "tutorTaughtLearnersWithLevels": null,
  "metadataTags": [
    {
      "id": 125525,
      "slug": "approachable",
      "translatedName": "Approachable",
      "__typename": "MetadataTag"
    },
    {
      "id": 125542,
      "slug": "patient",
      "translatedName": "Patient",
      "__typename": "MetadataTag"
    }
  ],
  "__typename": "TutorNodeES",
  "tutorName": "Sarah D.",
  "tutorFirstName": "Sarah",
  "avatarUrl": "https://avatars.preply.com/i/logos/i/logos/avatar_uxjpn4e5i1.jpg",
  "isOnline": false,
  "countryName": "United Kingdom",
  "currencyCode": "EUR",
  "priceValue": 42.5,
  "languages": [
    {
      "name": "Spanish",
      "levelCode": "B1",
      "language": "es"
    },
    {
      "name": "Italian",
      "levelCode": "B2",
      "language": "it"
    },
    {
      "name": "English",
      "levelCode": "Native",
      "language": "en"
    }
  ],
  "attributesList": [
    "IS_SUPER_TUTOR",
    "IS_CERTIFIED_TUTOR",
    "IS_POPULAR_TUTOR_LESSONS",
    "HAS_CONSECUTIVE_FIVE_RATED_LESSONS"
  ],
  "subjectAliases": [
    "english"
  ],
  "metadataTagSlugs": [
    "approachable",
    "patient"
  ]
}
````

You can download the full dataset in **JSON, HTML, CSV, or Excel** format — whichever works best for your workflow.

***

### Is it legal to scrape Preply?

This Actor only extracts **publicly available** information that is already displayed on Preply's tutor search pages. No private data (emails, phone numbers, private messages) is collected.

As with any web scraping tool, you should review and comply with Preply's Terms of Service. This tool is designed for legitimate use cases like market research, competitive analysis, and finding suitable tutors.

***

### Why use this Actor?

Preply doesn't offer a public API for searching and exporting tutor data. This Actor fills that gap by giving you structured, filterable access to Preply's tutor database — without needing to manually browse pages or copy-paste data.

Plus, because it runs on the Apify platform, you get:

- **Scheduling** — run it automatically on a daily or weekly basis
- **API access** — trigger runs and fetch data programmatically
- **Integrations** — send data to Google Sheets, Airtable, Slack, or any Zapier/Make workflow
- **Cloud storage** — all data is stored securely in Apify datasets

***

### FAQ

#### How many tutors can I scrape in one run?

As many as you want. You control the limit via `maxPages` and `maxTutors`. By default it scrapes 5 pages (~100 tutors), but you can increase this to scrape thousands.

#### Can I scrape tutors for multiple subjects at once?

Each run scrapes one subject. You can schedule separate runs for different subjects, or run the Actor multiple times with different inputs.

#### Can I get tutor contact information?

No — Preply does not expose email addresses, phone numbers, or other private contact information in its search results. Only public profile data is available.

#### Will I get blocked?

The Actor includes built-in delays to avoid rate limiting. For large-scale scraping, using residential proxies is recommended for extra reliability.

#### What export formats are available?

Apify datasets support export to **JSON, CSV, Excel, HTML, XML, and RSS** — pick whatever format you need.

# Actor input Schema

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

The subject to search for (e.g., 'english', 'spanish', 'french', 'german', 'math'). Uses the subject alias as seen in Preply URLs.

## `city` (type: `string`):

Filter tutors by city. Use 'online' for all online tutors.

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

Maximum number of result pages to scrape (1 page = ~20 tutors). Set to 0 for unlimited (scrapes all available).

## `maxTutors` (type: `integer`):

Maximum number of tutor profiles to scrape. Set to 0 for unlimited.

## `sort` (type: `string`):

Sort tutors by a specific criterion.

## `searchText` (type: `string`):

Free-text search query to filter tutors (e.g., 'business English', 'exam preparation').

## `priceRange` (type: `string`):

Price range filter in format 'min-max' (e.g., '10-30' for tutors between $10 and $30 per hour).

## `countryOfBirth` (type: `string`):

Filter tutors by country of birth. Use 2-letter ISO country code (e.g., 'US', 'GB', 'NL', 'UA', 'PL').

## `nativeSpeaker` (type: `boolean`):

Only show tutors who are native speakers of the subject language.

## `superTutor` (type: `boolean`):

Only show tutors with Super Tutor status.

## `professionalTutor` (type: `boolean`):

Only show certified/professional tutors.

## `availabilityTimes` (type: `string`):

Filter by time slots when tutors are available. Comma-separated values: MORNING\_LATE (9-12), AFTERNOON (12-15), AFTERNOON\_LATE (15-18), EVENING (18-21), EVENING\_LATE (21-0), NIGHT (0-3), NIGHT\_LATE (3-6), MORNING (6-9). E.g., 'EVENING,EVENING\_LATE'.

## `availabilityDays` (type: `string`):

Filter by days when tutors are available. Comma-separated 3-letter day codes: mon, tue, wed, thu, fri, sat, sun. E.g., 'mon,wed,fri'.

## `specialties` (type: `string`):

Filter by tutor specialties/tags. Comma-separated values. Common examples: 'bus\_gen' (Business English), 'conv\_gen' (Conversational), 'testprep\_ielts' (IELTS), 'american\_eng', 'british\_eng', 'toefl', 'en\_gchi' (English for children). E.g., 'bus\_gen,conv\_gen'.

## `targetLanguage` (type: `string`):

Filter tutors who speak a specific target language. Use 2-letter language code (e.g., 'ru' for Russian, 'es' for Spanish, 'fr' for French, 'zh' for Chinese).

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

Proxy settings. Using residential proxies may help avoid rate limiting.

## Actor input object example

```json
{
  "subject": "english",
  "city": "online",
  "maxPages": 5,
  "maxTutors": 0,
  "sort": "",
  "searchText": "",
  "priceRange": "",
  "countryOfBirth": "",
  "nativeSpeaker": false,
  "superTutor": false,
  "professionalTutor": false,
  "availabilityTimes": "",
  "availabilityDays": "",
  "specialties": "",
  "targetLanguage": "",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing all scraped tutor profiles with ratings, pricing, languages, and more

## `summary` (type: `string`):

JSON summary of the scrape run including subject, filter criteria, and total tutors scraped

# 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 = {
    "subject": "english",
    "city": "online"
};

// Run the Actor and wait for it to finish
const run = await client.actor("epicscrapers/preply-tutor-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 = {
    "subject": "english",
    "city": "online",
}

# Run the Actor and wait for it to finish
run = client.actor("epicscrapers/preply-tutor-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 '{
  "subject": "english",
  "city": "online"
}' |
apify call epicscrapers/preply-tutor-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Preply Tutor Scraper",
        "description": "Extract tutor profiles, prices, ratings, and availability data from Preply.com. Filter by subject, country, native speaker status, availability, and more. Perfect for market research, competitor analysis, and lead generation in online tutoring.",
        "version": "1.0",
        "x-build-id": "m8NCgsN5b1YyYdWH1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/epicscrapers~preply-tutor-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-epicscrapers-preply-tutor-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/epicscrapers~preply-tutor-scraper/runs": {
            "post": {
                "operationId": "runs-sync-epicscrapers-preply-tutor-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/epicscrapers~preply-tutor-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-epicscrapers-preply-tutor-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": [
                    "subject"
                ],
                "properties": {
                    "subject": {
                        "title": "Subject",
                        "type": "string",
                        "description": "The subject to search for (e.g., 'english', 'spanish', 'french', 'german', 'math'). Uses the subject alias as seen in Preply URLs.",
                        "default": "english"
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "Filter tutors by city. Use 'online' for all online tutors.",
                        "default": "online"
                    },
                    "maxPages": {
                        "title": "Max Pages",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of result pages to scrape (1 page = ~20 tutors). Set to 0 for unlimited (scrapes all available).",
                        "default": 5
                    },
                    "maxTutors": {
                        "title": "Max Tutors",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of tutor profiles to scrape. Set to 0 for unlimited.",
                        "default": 0
                    },
                    "sort": {
                        "title": "Sort Order",
                        "enum": [
                            "",
                            "price_lowest",
                            "price_highest",
                            "popularity",
                            "reviews",
                            "rating",
                            "no"
                        ],
                        "type": "string",
                        "description": "Sort tutors by a specific criterion.",
                        "default": ""
                    },
                    "searchText": {
                        "title": "Search Text",
                        "type": "string",
                        "description": "Free-text search query to filter tutors (e.g., 'business English', 'exam preparation').",
                        "default": ""
                    },
                    "priceRange": {
                        "title": "Price Range",
                        "type": "string",
                        "description": "Price range filter in format 'min-max' (e.g., '10-30' for tutors between $10 and $30 per hour).",
                        "default": ""
                    },
                    "countryOfBirth": {
                        "title": "Country of Birth",
                        "type": "string",
                        "description": "Filter tutors by country of birth. Use 2-letter ISO country code (e.g., 'US', 'GB', 'NL', 'UA', 'PL').",
                        "default": ""
                    },
                    "nativeSpeaker": {
                        "title": "Native Speaker Only",
                        "type": "boolean",
                        "description": "Only show tutors who are native speakers of the subject language.",
                        "default": false
                    },
                    "superTutor": {
                        "title": "Super Tutor Only",
                        "type": "boolean",
                        "description": "Only show tutors with Super Tutor status.",
                        "default": false
                    },
                    "professionalTutor": {
                        "title": "Professional Tutor Only",
                        "type": "boolean",
                        "description": "Only show certified/professional tutors.",
                        "default": false
                    },
                    "availabilityTimes": {
                        "title": "Availability Times",
                        "type": "string",
                        "description": "Filter by time slots when tutors are available. Comma-separated values: MORNING_LATE (9-12), AFTERNOON (12-15), AFTERNOON_LATE (15-18), EVENING (18-21), EVENING_LATE (21-0), NIGHT (0-3), NIGHT_LATE (3-6), MORNING (6-9). E.g., 'EVENING,EVENING_LATE'.",
                        "default": ""
                    },
                    "availabilityDays": {
                        "title": "Availability Days",
                        "type": "string",
                        "description": "Filter by days when tutors are available. Comma-separated 3-letter day codes: mon, tue, wed, thu, fri, sat, sun. E.g., 'mon,wed,fri'.",
                        "default": ""
                    },
                    "specialties": {
                        "title": "Specialties",
                        "type": "string",
                        "description": "Filter by tutor specialties/tags. Comma-separated values. Common examples: 'bus_gen' (Business English), 'conv_gen' (Conversational), 'testprep_ielts' (IELTS), 'american_eng', 'british_eng', 'toefl', 'en_gchi' (English for children). E.g., 'bus_gen,conv_gen'.",
                        "default": ""
                    },
                    "targetLanguage": {
                        "title": "Target Language",
                        "type": "string",
                        "description": "Filter tutors who speak a specific target language. Use 2-letter language code (e.g., 'ru' for Russian, 'es' for Spanish, 'fr' for French, 'zh' for Chinese).",
                        "default": ""
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Using residential proxies may help avoid rate limiting.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
