# Superprof Scraper \[$0.9💰] | Tutor Data | 7 Country Sites (`ahmed_jasarevic/superprof-scraper`) Actor

Scrape Superprof tutor profiles across .fr, .es, .co.uk, .com.br, .com, .ae and .co.in: name, hourly price, subjects, location and ratings. Built for tutor lead generation, tutoring market research and private tutor price comparison. Structured JSON via API.

- **URL**: https://apify.com/ahmed_jasarevic/superprof-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.88 / 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Superprof Scraper

The **Superprof Scraper** extracts 29-field tutor records from Superprof's own internal `/a/search/` JSON API across 7 verified country domains (`.fr`, `.es`, `.co.uk`, `.com.br`, `.com`, `.ae`, `.co.in`) — one row per tutor with name, photo, hourly price, currency, rating, review count, city and profile URL. It is built for **tutor lead generation** and **tutoring market research**: plain HTTP requests, no browser, no proxy, and no login — while DataDome returns `403` on Superprof's HTML, the JSON endpoint answers `200` from Apify's default network.

### Use Cases — Tutor Lead Generation, Tutoring Market Research & Private Tutor Price Comparison

- **Tutor lead generation** — collect tutor names, profile URLs, response times, verified badges and free-first-lesson flags to build outreach-ready segments for tutoring services, agencies and edtech funnels (no emails or phone numbers — see FAQ).
- **Tutoring market research** — count and compare tutor listings by subject, city and country: how many tutors teach maths in Lyon versus London, or English in Madrid versus Mumbai.
- **Private tutor price comparison** — benchmark `hourlyPrice` + `currency` per subject and city straight from the dataset — the data needed to build a tutor comparison tool.
- **Math tutors near me** — Superprof's city landing pages ("Math tutors near me in …") map straight to search URLs; the returned rows carry `city`, `country` and `distanceKm`.
- **Education marketplace data** — populate a tutoring marketplace, global tutor database or price-benchmarking product with structured tutor listings data: identity, price, rating, reviews and provenance in every row.
- **Tutoring platforms compared** — pull Superprof rows alongside Preply or italki datasets to compare rates, ratings and free-first-lesson offers across tutoring platforms.

### Build A Superprof Tutor Database Without Official API Access

Superprof publishes no official developer API, so this Actor calls the site's own internal search endpoint — the JSON API the search page itself uses via XHR when you click "next page" or change filters. Paste a normal Superprof search URL (`https://www.superprof.fr/s/guitare,France,Paris,,,,.html`); the Actor maps it to `/a/search/?adress=<place>&matiere=<subject>&page=<N>`, pages the results as pure JSON and writes one row per tutor to the default dataset. It is a `CheerioCrawler` (HTTP + JSON parsing) at 256 MB with no Chrome — fast runs, low compute cost. Profile enrichment is off by default; endpoint, anti-bot and proxy detail follow below.

### Superprof API Alternative: Structured Tutor Data With No Browser And No Login

#### The endpoint

```
GET https://www.superprof.<tld>/a/search/?adress=<place>&matiere=<subject>&page=<N>
Accept: application/json
X-Requested-With: XMLHttpRequest          (optional)
```

Superprof's public HTML (all regional domains) sits behind **DataDome** (plus **AWS WAF** on the proxy path): a plain request to `www.superprof.*` returns `403` with a CAPTCHA. Rendering that headless is the expensive, fragile path — so this Actor never loads the search-results page; the internal JSON endpoint answers regular HTTP from Apify's network with no challenge at all.

- **Why this endpoint:** it returns the complete search-card payload as pure JSON — tutor id, name, photo, hourly price, `teacherRating {average,count}`, city, response time, webcam / face-to-face flags, free-first-lesson flag, badges, profile URL — with a `nbPagesTotal` counter, and it is cheap to page through (`page=1…N`).
- **URL mapping:** the Actor derives the API call from the public search URL a user copies from the browser — `/s/{subject},{Country},{City},,…` → `adress=<City|Country>`, `matiere=<subject>`, `page=<N>` (slugs decoded: `united-kingdom` → `United Kingdom`).
- **Defensive fallback:** if a page comes back with an empty result set, the same request is retried with *minimal* parameters (only `adress`, `matiere`, `page`), so stray query params copied from the page URL can't zero out the results.
- **Profile enrichment (optional, off by default):** profile pages are parsed with Cheerio (`bio`, `subjects`, `geo`, ld+json price/rating) with layered selectors that degrade gracefully — see the known limitation below.
- **Hard safety caps in the code:** max 500 items, max 50 pages per search, max 800 requests per run, concurrency 3, 1 retry, 45 s per request — a runaway crawl is impossible.

**No Playwright / no browser is used.** The `/a/search/` endpoint is reverse-engineered, not official — if Superprof changes it, the fallbacks and diagnostics record surface that immediately in the dataset.

### Anti-Bot, DataDome & Proxy Settings: Why This Scraper Runs With The Proxy Off

Measured live against `superprof.fr` and `superprof.co.uk`, not guessed:

| Network | Internal search JSON (`/a/search/`) | Profile HTML |
| --- | --- | --- |
| **Direct, no proxy (default)** | ✅ 200 — full records | ❌ DataDome 403 |
| Apify proxy, datacenter group | ❌ DataDome 403 | – |
| Apify proxy, `UNBLOCKER` group | ❌ AWS WAF 405 (captcha) | – |
| Apify proxy, `RESIDENTIAL` group | ❌ AWS WAF 405 (captcha) | ❌ AWS WAF 405 (captcha) |

So the cheapest, fastest configuration is **the default: proxy OFF**. The proxy input is still provided for any future Superprof behaviour change — if runs start blocking, retry with the proxy *off* first, then with the `UNBLOCKER` group. Blocked runs push a single diagnostic record — `{"__error": "blocked_by_bot_protection", "hint": …}` with per-request diagnostics — visible straight from the dataset.

#### Known limitation — profile pages (bio / subjects / geo)

Profile HTML is protected by **DataDome** (datacenter IPs) and **AWS WAF** (every tested Apify proxy group). Until a network passes, `bio` and `geo` stay empty and `subjects` holds the searched subject only (`subjectsFromSearch: true` marks that case); the code aborts the phase after the first blocked request instead of burning one per tutor. Everything else — name, photo, headline, price, rating, review count, city, country, response time, lesson type, free-first-lesson, badges, profile URL — comes straight from the search JSON and is complete. Profiles at scale would need browser-based stealth, a paid anti-bot API (Scrapfly/Zyte) or a paid Superprof data API (e.g. parse.bot's `get_tutor_profile`).

### Input Parameters

| Field | Type | Required | Default | Notes |
| --- | --- | --- | --- | --- |
| `startUrls` | array | No | 4 examples (`.fr` / `.co.uk` / `.es` / `.com.br`) | Superprof **search-results URLs** (`/s/subject,Country,City,,,,.html`) on any regional domain. Plain **tutor profile URLs** are accepted too and scraped directly. Leave empty to use the built-in examples. |
| `maxItems` | integer | No | `60` (10 on the free plan) | Cap on collected tutors, 1–500. |
| `maxPages` | integer | No | `3` (1 on the free plan) | Result pages pulled per start URL from `/a/search/`, 1–50. |
| `fetchProfiles` | boolean | No | `false` | **Experimental.** Visit profile pages for bio/subjects/geo — blocked by anti-bot on every tested network; keep off (the code aborts after the first block anyway). |
| `debugDump` | boolean | No | `false` | Push raw API/HTML responses into the dataset for troubleshooting (leave off for normal runs). |
| `proxy` | object | No | `{ "useApifyProxy": false }` | Standard Apify proxy picker. Leave it **off** — the measured table above shows proxy-on runs get blocked. |

Free-plan runs are capped at 10 tutors and 1 page per search (`APIFY_USER_IS_PAYING=1` lifts the cap).

### Output Fields

Rows land in the default dataset (table view **Tutors**: name, city, price/h, currency, rating, reviews, subjects, bio, profile) — one row per tutor, 29 fields:

- **Identity** — `tutorId`, `name`, `photo`, `title` (headline), `profileUrl`.
- **Pricing** — `hourlyPrice` and `currency`, inferred from the regional domain (EUR/GBP/BRL/USD/…). Prices are geo-dependent and refreshed per run; `scrapedAt` stamps the snapshot.
- **Subjects** — `subjects` (array) and `subjectsFromSearch`: the searched subject by default (`subjectsFromSearch: true`); full lists come from profile pages (see the limitation section).
- **Reputation** — `rating` and `reviewCount` from the payload's `teacherRating {average,count}`, plus `responseTime` ("in less than an hour", …).
- **Location** — `city` and `distanceKm` from the search cards, `country` derived from the search URL, `geo` coordinates (profile pages — blocked).
- **Lesson format** — `lessonOnline` (webcam) and `lessonInPerson` (face-to-face).
- **Trial lesson** — `freeFirstLesson` and `firstFreeDuration` (e.g. "1h").
- **Quality signals** — `verified` boolean and `badge` string from the search payload.
- **Profile text** — `bio` (profile pages — blocked, stays `null`).
- **Provenance** — `searchUrl`, `sourceDomain`, `scrapedAt` on every row.
- **Failure diagnostics (failed runs only)** — `__error`, `hint`, `diagnostics` (per-request array): a blocked or empty run pushes one diagnostic record instead of tutor rows.

### Example Input And Output

#### Example Input

```bash
apify call ahmed_jasarevic/superprof-scraper --input-file=input.json --output-dataset
```

```json
{
  "startUrls": [{ "url": "https://www.superprof.fr/s/maths,France,Lyon,,,,.html" }],
  "maxItems": 20,
  "maxPages": 2
}
```

#### Example Output

```json
{
  "tutorId": "4298123",
  "name": "Camille R.",
  "photo": "https://media.superprof.fr/i/a/preview/teacher-4298123.jpg",
  "title": "Maths tutor, engineering graduate",
  "profileUrl": "https://www.superprof.fr/camille-r.html",
  "hourlyPrice": 35,
  "currency": "EUR",
  "subjects": ["Maths"],
  "subjectsFromSearch": true,
  "rating": 4.9,
  "reviewCount": 127,
  "city": "Lyon",
  "country": "France",
  "distanceKm": null,
  "geo": null,
  "bio": null,
  "responseTime": "in less than an hour",
  "lessonOnline": true,
  "lessonInPerson": true,
  "freeFirstLesson": true,
  "firstFreeDuration": "1h",
  "verified": true,
  "badge": "superprof",
  "searchUrl": "https://www.superprof.fr/s/maths,France,Lyon,,,,.html",
  "sourceDomain": "www.superprof.fr",
  "scrapedAt": "2026-10-08T09:24:11.000Z"
}
```

`geo`, `bio` and `distanceKm` are `null` here (profile pages blocked, no distance on the card); the rest comes straight from the search JSON.

### Integrations & Automation

- **Apify API** — start runs, pass input and read results over REST (`POST /v2/acts/{actorId}/runs`, then `GET /v2/datasets/{datasetId}/items`), or use the CLI shown above.
- **Webhooks** — fire on *run succeeded* to push rows into your CRM, warehouse or Google Sheet; failed runs fire too, carrying the diagnostic record.
- **Zapier & Make** — Apify's official integrations trigger scenarios from this Actor's runs, so non-developers can move rows into a spreadsheet or lead database.
- **Recurring schedule** — a **weekly** run on a fixed set of city/subject search URLs is the realistic cadence for monitoring prices or a lead pool without hammering the endpoint (prices are geo-dependent, refreshed per run). Schedules also keep Store recommendation signals alive.

### Related Actors

- [azzouzana/superprof-scraper](https://apify.com/azzouzana/superprof-scraper) — the largest same-name Superprof actor on the Store (44 users); its listing publishes the "education scraper" keyword.
- [abotapi/superprof-tutor-scraper](https://apify.com/abotapi/superprof-tutor-scraper) — Superprof tutor scraping with price/rating/lesson-type filters and incremental mode.
- [memo23/superprof-scraper](https://apify.com/memo23/superprof-scraper) — per its Store listing, Superprof across 17 country sites via the mobile app's JSON API through Apify Unblocker (this Actor uses the public `/a/search/` endpoint with the proxy off).
- [preply-scraper](https://apify.com/ahmed_jasarevic/preply-scraper) — Preply tutor profiles and reviews, for the tutoring-platform comparison side of the same market.
- [italki-teacher-tutor-directory-scraper](https://apify.com/jungle_synthesizer/italki-teacher-tutor-directory-scraper) — the italki "Tutor Directory Scraper", one of two same-titled Store actors cited in this niche's research.

### FAQ

#### Is there an official Superprof API?

No. Superprof publishes no official developer API — parse.bot, which sells a paid "Superprof API" product, says the same in its own FAQ. This Actor uses the internal `/a/search/` endpoint instead, reverse-engineered from the search page's XHR traffic; it is not official, and the fallbacks plus dataset diagnostics surface any change Superprof makes to it.

#### How do I scrape Superprof without getting blocked?

Use the internal JSON endpoint, not the HTML pages: HTML sits behind DataDome (plus AWS WAF) and returns `403` with a CAPTCHA, while `/a/search/` answers plain HTTP from Apify's default network with `200` — measured live on `superprof.fr` and `superprof.co.uk`. Keep the proxy **off** and `fetchProfiles` disabled; if a run is still blocked, the dataset carries `__error` / `hint` / `diagnostics` instead of silent emptiness.

#### Do I need proxies or a browser to scrape Superprof?

No — measured runs show both hurt. This Actor is a `CheerioCrawler`: no Playwright, no Chrome (256 MB), proxy off. Direct HTTP returns full records from `/a/search/`; the datacenter proxy group hits DataDome `403`, the `UNBLOCKER`/`RESIDENTIAL` groups hit AWS WAF `405` (captcha).

#### How much do tutors charge — and how much does private tutoring cost per hour?

The dataset answers this empirically: every row carries `hourlyPrice` plus `currency`, inferred from the regional domain (EUR on `.fr`, GBP on `.co.uk`, BRL on `.com.br`, USD, INR on `.co.in`, …). Aggregate by `subjects`, `city` or `country` to compare rates per market — e.g. private maths tutor price in a UK city versus an Indian one. No unverified price figures are quoted here.

#### Which countries and Superprof sites does this scraper support?

Any regional domain passed in `startUrls`; the verified set is `.fr`, `.es`, `.co.uk`, `.com.br`, `.com`, `.ae` and `.co.in`. The search URL's domain also determines the derived `country` and the inferred `currency`. Superprof runs many more country sites than these seven — untested domains may work, but start with the verified set.

#### What data can you actually get from a Superprof search results page?

Everything the search cards show — see **Output Fields** above for the full list: identity, `hourlyPrice` + `currency`, `subjects`, `rating`, `reviewCount`, `city`, `distanceKm`, `responseTime`, lesson flags, free-first-lesson, `verified`, `badge`, provenance. The exceptions: `bio` and `geo` need profile pages (currently blocked — keep `fetchProfiles` off), and `__error`/`hint`/`diagnostics` appear only on failed runs.

#### Which is cheaper, Superprof or Preply?

This Actor claims no winner — it gives you the fields to answer it: take `hourlyPrice` + `currency` rows from Superprof and from a Preply dataset, and compare like-for-like by subject, rating band and lesson type. Three comparison articles (superprof.ca, superprof.co.uk, preply.com's blog) compete for the head-to-head query — comparable structured data beats quoted numbers.

#### Can I get tutor emails and phone numbers for lead generation?

No. The dataset schema has no email or phone fields — only public search-result data: names, photos, profile URLs, prices, ratings, cities, badges. Lead generation here means a qualified list of tutors and profile URLs to review, not a contact list. (A competing Store actor advertises "emails (when available)"; that is not this Actor's output.)

#### What are the alternatives to the Superprof Scraper?

On the Apify Store: `azzouzana/superprof-scraper`, `abotapi/superprof-tutor-scraper` and `memo23/superprof-scraper` (see Related Actors). For the comparison side, scrape the other tutoring platforms — Preply, Wyzant and MyTutor are the recurring Superprof comparison points, with italki alternatives content ranking for the same audience. For full profile pages at scale: a paid anti-bot API (Scrapfly/Zyte) or a paid Superprof data API (e.g. parse.bot's `get_tutor_profile`), since profile HTML is blocked on every tested network.

#### How do I compare tutor prices across countries and currencies?

Set one `startUrls` entry per country domain — each run infers its `currency` from the regional site, so GBP, EUR and INR rows land in one dataset, joinable on `subjects` and `city`/`country` with `scrapedAt` stamps.

### SEO Keywords

superprof scraper, superprof api, superprof tutor data, tutor directory scraper, tutor data extractor, education scraper, tutor lead generation, tutoring market research, private tutor price comparison, education marketplace data, tutor listings data, global tutor database, tutoring platforms, preply alternatives, superprof vs preply, private tutoring market, online tutoring industry, tutor pricing data, tutor hourly rate, how much do tutors charge, how much does private tutoring cost, private maths tutor price, math tutors near me, private tutoring cost uk, private math tutor rates india

### For AI Agents & LLM Apps

**Purpose:** one run turns Superprof search URLs into tabular tutor rows (name, price, rating, location, badges) via the site's internal `/a/search/` JSON endpoint — no browser, no login.

**Minimal working input:**

```json
{
  "startUrls": [{ "url": "https://www.superprof.co.uk/s/maths,United-Kingdom,London,,,,.html" }]
}
```

All six fields are optional (`required: []`); empty `startUrls` falls back to four built-in example searches.

**Output fields (29):** `tutorId`, `name`, `photo`, `title`, `profileUrl`, `hourlyPrice`, `currency`, `subjects`, `subjectsFromSearch`, `rating`, `reviewCount`, `city`, `country`, `geo`, `bio`, `responseTime`, `lessonOnline`, `lessonInPerson`, `freeFirstLesson`, `firstFreeDuration`, `verified`, `badge`, `distanceKm`, `searchUrl`, `sourceDomain`, `scrapedAt`, `__error`, `hint`, `diagnostics`.

**Behaviors an agent should know:**

- The country site — and thus `country` and the inferred `currency` — follows the domain of each `startUrls` entry; path slugs are decoded (`united-kingdom` → `United Kingdom`).
- Defaults if unset: `maxItems: 60`, `maxPages: 3`, `fetchProfiles: false`, `debugDump: false`, `proxy.useApifyProxy: false`. Free plan: 10 tutors and 1 page (`APIFY_USER_IS_PAYING=1` lifts it).
- Hard caps: 500 items, 50 pages/search, 800 requests/run, concurrency 3, 1 retry, 45 s/request.
- Leave the proxy **off**: direct HTTP returns `200`; every tested proxy group got blocked (DataDome `403` / AWS WAF `405`).
- `fetchProfiles: true` adds currently-blocked profile requests: `bio`/`geo` stay `null`, `subjects` holds only the searched subject (`subjectsFromSearch: true`), and the phase aborts after the first block.
- Failed runs push one diagnostic row (`__error`, `hint`, `diagnostics`) instead of tutor rows — read it before retrying.
- An empty result page retries with minimal parameters (`adress`, `matiere`, `page`) before a row is dropped.

### Legal & Compliance Disclaimer

This is an independent tool. It is not affiliated with, endorsed by, sponsored by, or officially connected to Superprof (the platform operated by Superprof SAS).

The Actor reads only publicly available Superprof search-result JSON — the same data the public page renders — without login, authentication bypass or CAPTCHA solving. Profile enrichment (`fetchProfiles`) is off by default and blocked by anti-bot on every tested network anyway; the `/a/search/` endpoint is reverse-engineered, not an official API.

You are responsible for your own compliance with Superprof's Terms of Service and applicable data-protection law. The output is personal data about identifiable tutors (names, photos, cities, profile URLs, bios where available) — especially relevant under GDPR and UK GDPR given the `.fr`, `.es` and `.co.uk` country sites.

The dataset contains no email addresses or phone numbers; if you combine these rows with other sources for outreach, any resulting commercial messaging must comply with applicable anti-spam and marketing law (including GDPR and ePrivacy rules).

# Actor input Schema

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

Superprof search-results pages (e.g. https://www.superprof.fr/s/guitare,France,Paris,,,,.html) on any regional domain (.fr .es .co.uk .com.br .com ...). Tutor profile URLs are also accepted and scraped directly. Leave empty to use the built-in examples.

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

Maximum number of tutors to collect in one run.

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

How many result pages to pull from the internal search API for each start URL.

## `fetchProfiles` (type: `boolean`):

EXPERIMENTAL: visit each tutor's profile page for bio, subjects taught and geo. Superprof's anti-bot blocks profile HTML from every tested network (DataDome on direct IPs, AWS WAF on proxies), so this usually only adds blocked requests — keep it off unless you retry with a proxy setup that works.

## `debugDump` (type: `boolean`):

Push the raw API/HTML responses into the dataset for troubleshooting (leave off for normal runs).

## `proxy` (type: `object`):

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.superprof.fr/s/guitare,France,Paris,,,,.html"
    },
    {
      "url": "https://www.superprof.co.uk/s/maths,United-Kingdom,London,,,,.html"
    },
    {
      "url": "https://www.superprof.es/s/ingles,Spain,Madrid,,,,.html"
    },
    {
      "url": "https://www.superprof.com.br/s/matematica,Brazil,Sao-Paulo,,,,.html"
    }
  ],
  "maxItems": 60,
  "maxPages": 3,
  "fetchProfiles": false,
  "debugDump": false,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://www.superprof.fr/s/guitare,France,Paris,,,,.html"
        },
        {
            "url": "https://www.superprof.co.uk/s/maths,United-Kingdom,London,,,,.html"
        },
        {
            "url": "https://www.superprof.es/s/ingles,Spain,Madrid,,,,.html"
        },
        {
            "url": "https://www.superprof.com.br/s/matematica,Brazil,Sao-Paulo,,,,.html"
        }
    ],
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/superprof-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startUrls": [
        { "url": "https://www.superprof.fr/s/guitare,France,Paris,,,,.html" },
        { "url": "https://www.superprof.co.uk/s/maths,United-Kingdom,London,,,,.html" },
        { "url": "https://www.superprof.es/s/ingles,Spain,Madrid,,,,.html" },
        { "url": "https://www.superprof.com.br/s/matematica,Brazil,Sao-Paulo,,,,.html" },
    ],
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/superprof-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.superprof.fr/s/guitare,France,Paris,,,,.html"
    },
    {
      "url": "https://www.superprof.co.uk/s/maths,United-Kingdom,London,,,,.html"
    },
    {
      "url": "https://www.superprof.es/s/ingles,Spain,Madrid,,,,.html"
    },
    {
      "url": "https://www.superprof.com.br/s/matematica,Brazil,Sao-Paulo,,,,.html"
    }
  ],
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call ahmed_jasarevic/superprof-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/superprof-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/ItxwnTbfUXgva7WSQ/builds/MEQWDiHQ7Qf5EowyS/openapi.json