# Wyzant Tutors Scraper (`crawlerbros/wyzant-scraper`) Actor

Scrape tutor profiles from Wyzant.com with the largest US tutoring marketplace. Search tutors by subject or keyword, browse subject pages, or fetch individual tutor profiles. Returns name, subjects, hourly rate, rating, reviews, education, bio, and more.

- **URL**: https://apify.com/crawlerbros/wyzant-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Developer tools, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 3 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

## Wyzant Tutors Scraper

Extract tutor profiles from [Wyzant.com](https://www.wyzant.com) — the largest US online tutoring marketplace with 80,000+ tutors across all subjects. Collect tutor names, subjects, hourly rates, ratings, reviews, education backgrounds, bios, and more.

### What You Can Scrape

- **Search tutors** by subject or keyword (math, calculus, SAT prep, Python, etc.)
- **Browse by subject** — all tutors for a given subject category
- **Individual tutor profiles** — full details for specific tutors
- **Filter by** hourly rate, star rating, online availability, and location

### Output Data

Each record includes:

| Field | Description |
|-------|-------------|
| `name` | Tutor's display name |
| `url` | Wyzant profile URL |
| `tutorId` | Wyzant username |
| `subjects` | Array of subjects taught |
| `hourlyRate` | Hourly rate in USD |
| `rating` | Average star rating (0–5) |
| `reviewCount` | Number of student reviews |
| `numStudents` | Total number of students tutored |
| `numHours` | Total tutoring hours completed |
| `responseTime` | Typical response time |
| `backgroundChecked` | `true` if background check verified |
| `education` | Array of `{degree, subject, institution}` objects |
| `bio` | Tutor biography/description |
| `location` | City/state |
| `onlineTutoring` | `true` if available online |
| `photoUrl` | Profile photo URL |
| `scrapedAt` | ISO 8601 timestamp |

### Input Options

#### Mode

| Mode | Description |
|------|-------------|
| `search` | Search tutors by keyword or subject (default) |
| `bySubject` | Browse all tutors for a subject category |
| `tutorProfile` | Fetch a single tutor's full profile |
| `byUrl` | Scrape individual tutor URL(s) |

#### Filters

- **Online only**: filter to tutors offering online sessions (default: `true`)
- **Min/max hourly rate**: filter by USD rate range
- **Min rating**: filter to tutors with rating ≥ threshold
- **ZIP code**: find nearby in-person tutors

#### Example Inputs

**Search for math tutors online:**
```json
{
  "mode": "search",
  "searchQuery": "calculus",
  "onlineOnly": true,
  "maxItems": 20
}
````

**Browse all Python tutors:**

```json
{
  "mode": "bySubject",
  "subject": "python",
  "maxItems": 50
}
```

**Get a single tutor profile:**

```json
{
  "mode": "tutorProfile",
  "tutorUsername": "john_s"
}
```

**Filter by rate range:**

```json
{
  "mode": "search",
  "searchQuery": "SAT prep",
  "minRate": 50,
  "maxRate": 100,
  "onlineOnly": true,
  "maxItems": 30
}
```

**Scrape specific tutor pages:**

```json
{
  "mode": "byUrl",
  "startUrls": [
    {"url": "https://www.wyzant.com/tutors/jane_d"}
  ]
}
```

### Use Cases

- **EdTech platforms** — build tutor comparison databases
- **Academic lead generation** — find qualified tutors by subject and location
- **Market research** — analyze tutoring rate benchmarks by subject
- **Student tools** — match students with tutors based on budget and subject
- **Competitive analysis** — track tutor availability and pricing trends

### FAQ

**Does this require login or cookies?**
No. Wyzant tutor profiles and search results are publicly accessible without authentication.

**What subjects are supported?**
All Wyzant subjects are supported via free-text search. Common subjects available as dropdown options include Math, Science, English, History, Foreign Languages, Computer Science, Music, and test prep (SAT/ACT/GRE).

**How accurate are hourly rates?**
Rates are scraped directly from each tutor's public profile page and reflect their listed rate at the time of scraping.

**Can I find in-person tutors?**
Yes — provide a `zipCode` and set `onlineOnly: false` to find local in-person tutors.

**Are Wyzant profiles updated frequently?**
Wyzant profiles are updated by tutors themselves. This scraper retrieves the current live data.

**How many tutors does Wyzant have?**
Wyzant has 80,000+ tutors across hundreds of subjects throughout the United States.

# Actor input Schema

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

What to fetch from Wyzant.

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

Subject or keyword to search for tutors (mode=search), e.g. `calculus`, `python programming`, `SAT prep`.

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

Browse tutors by subject category (mode=bySubject).

## `tutorUsername` (type: `string`):

Wyzant username for a single tutor profile (mode=tutorProfile), e.g. `john_s`.

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

List of Wyzant tutor profile URLs (mode=byUrl). Each item must have a `url` key, e.g. `https://www.wyzant.com/tutors/john_s`.

## `onlineOnly` (type: `boolean`):

If enabled, only return tutors available for online sessions.

## `zipCode` (type: `string`):

US ZIP code to filter for nearby in-person tutors (optional). Leave blank for online-only search.

## `minRate` (type: `integer`):

Minimum tutor hourly rate in USD.

## `maxRate` (type: `integer`):

Maximum tutor hourly rate in USD.

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

Minimum tutor rating (0.0 – 5.0).

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

Maximum number of tutor records to emit.

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

Apify proxy settings. Uses Apify AUTO datacenter proxy for Wyzant access.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "math",
  "subject": "math",
  "startUrls": [],
  "onlineOnly": true,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Dataset containing all scraped Wyzant tutor profile records.

# 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": "search",
    "searchQuery": "math",
    "subject": "math",
    "startUrls": [],
    "onlineOnly": true,
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/wyzant-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": "search",
    "searchQuery": "math",
    "subject": "math",
    "startUrls": [],
    "onlineOnly": True,
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/wyzant-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": "search",
  "searchQuery": "math",
  "subject": "math",
  "startUrls": [],
  "onlineOnly": true,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/wyzant-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Wyzant Tutors Scraper",
        "description": "Scrape tutor profiles from Wyzant.com with the largest US tutoring marketplace. Search tutors by subject or keyword, browse subject pages, or fetch individual tutor profiles. Returns name, subjects, hourly rate, rating, reviews, education, bio, and more.",
        "version": "1.0",
        "x-build-id": "53DRx4SFqQ3xnvgMm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~wyzant-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-wyzant-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~wyzant-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-wyzant-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~wyzant-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-wyzant-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": [
                            "search",
                            "bySubject",
                            "tutorProfile",
                            "byUrl"
                        ],
                        "type": "string",
                        "description": "What to fetch from Wyzant.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Subject or keyword to search for tutors (mode=search), e.g. `calculus`, `python programming`, `SAT prep`.",
                        "default": "math"
                    },
                    "subject": {
                        "title": "Subject",
                        "enum": [
                            "math",
                            "algebra",
                            "calculus",
                            "geometry",
                            "statistics",
                            "trigonometry",
                            "science",
                            "chemistry",
                            "physics",
                            "biology",
                            "earth-science",
                            "english",
                            "reading",
                            "writing",
                            "grammar",
                            "literature",
                            "history",
                            "us-history",
                            "world-history",
                            "government",
                            "spanish",
                            "french",
                            "mandarin",
                            "german",
                            "japanese",
                            "italian",
                            "computer-science",
                            "python",
                            "java",
                            "javascript",
                            "c-programming",
                            "html",
                            "music",
                            "piano",
                            "guitar",
                            "violin",
                            "sat",
                            "act",
                            "gre",
                            "gmat",
                            "lsat",
                            "business",
                            "accounting",
                            "economics",
                            "finance",
                            "marketing",
                            "writing-essays"
                        ],
                        "type": "string",
                        "description": "Browse tutors by subject category (mode=bySubject).",
                        "default": "math"
                    },
                    "tutorUsername": {
                        "title": "Tutor username",
                        "type": "string",
                        "description": "Wyzant username for a single tutor profile (mode=tutorProfile), e.g. `john_s`."
                    },
                    "startUrls": {
                        "title": "Start URLs (mode=byUrl)",
                        "type": "array",
                        "description": "List of Wyzant tutor profile URLs (mode=byUrl). Each item must have a `url` key, e.g. `https://www.wyzant.com/tutors/john_s`.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "onlineOnly": {
                        "title": "Online tutors only",
                        "type": "boolean",
                        "description": "If enabled, only return tutors available for online sessions.",
                        "default": true
                    },
                    "zipCode": {
                        "title": "ZIP code (in-person filter)",
                        "type": "string",
                        "description": "US ZIP code to filter for nearby in-person tutors (optional). Leave blank for online-only search."
                    },
                    "minRate": {
                        "title": "Min hourly rate ($)",
                        "minimum": 0,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Minimum tutor hourly rate in USD."
                    },
                    "maxRate": {
                        "title": "Max hourly rate ($)",
                        "minimum": 0,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum tutor hourly rate in USD."
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Minimum tutor rating (0.0 – 5.0)."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of tutor records to emit.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy settings. Uses Apify AUTO datacenter proxy for Wyzant access.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
