# Jameda Scraper \[411K Docs💰] | German Leads & Reviews (`ahmed_jasarevic/jameda-scraper`) Actor

Scrape jameda.de — Germany's largest doctor directory (411K+ doctors, 2.8M reviews): specialty × city profiles with +49 phones, insurance types, languages, opening hours, ratings and patient reviews.

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

## Pricing

from $1.20 / 1,000 profile scrapeds

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

## Jameda Scraper — German Doctor Profiles, Reviews & +49 Leads

Scrape **jameda.de** — Germany's largest online physician directory (411,000+ doctors, 2.8M+ verified patient reviews) — one specialty in one city per run, with up to 500 doctor profiles. Extract doctor profile data (name, practice address, +49 phone, verified insurance types, languages, opening hours, ratings, review count) and the **patient review dataset**, all in parallel. The cheapest way to build German healthcare lead and review datasets.

### Main Use Cases

- **Medical lead generation** — specialty × city searches return practices with +49 phone numbers and insurance (GKV/PKV) acceptance to target outreach.
- **Healthcare market research** — doctor supply and density, rating distributions, review volumes per specialty/city.
- **Doctor directory building** — a searchable Germany-wide database of doctors, therapists and other providers.
- **Competitor & employer monitoring** — practices' ratings and review sentiment over time.
- **Patient review analytics** — German reviews with per-review ratings for NLP/fine-tuning datasets.

### How It Works

The actor crawls jameda's **public search and profile pages** with a fast CheerioCrawler (parallel fetching, no browser, no login, no CAPTCHA). It walks the specialty+city search listing (~30 doctors a page, up to 50 listing pages), then per doctor scrapes the profile and, when enabled, the patient reviews server-rendered on the page. Phone numbers are normalized to **+49 international format**.

### Lead Generation: Build Doctor Lists with Validated Insurance Data

Each profile row contains `practiceName`, `fullName`, `streets` with the primary address, `phoneNumbers` (normalized +49), verified `insuranceTypes` (`GKV` gesetzlich / `PKV` privat) as jameda lists them, `languages`, `openingHours` and `types` (e.g. Facharzt). Use the parallel `specialties`/`cities` fields to crawl several specialty × city combos in one run — a clean, structured medical-practice contact database without scraping the whole directory.

### Scrape Doctor Reviews With Practice Responses

Set `includeReviews: true` and the separate reviews dataset fills with `title`, `body`, `rating` (1–5), `secondaryRating`, `reviewAward`, the **practice response** (`responseText`) when present, and `createdAt` dates — complete German healthcare review data for reputation research and health-NLP datasets.

### Input

| Field | Type | Required | Default | Notes |
|---|---|---|---|---|
| `specialty` | string | **Yes** | — | Specialty to search, e.g. `Hautarzt (Dermatologe)`, `Kardiologe`, `Zahnarzt` or a jameda slug like `hautarzt-dermatologe`. |
| `city` | string | **Yes** | — | German city, e.g. `Berlin`, `München` or a slug like `muenchen`. |
| `specialties` | array | No | — | Extra specialties crawled **in parallel** in the same run (combined with `cities`, every pair is crawled concurrently). |
| `cities` | array | No | — | Extra cities crawled in parallel. |
| `maxResults` | integer | No | `50` | Max doctor profiles overall (all specialty+city combos combined, hard cap **500**). |
| `maxPagesPerListing` | integer | No | `5` | Max search-listing pages per specialty+city (~30 doctors each), 1–50. |
| `includeReviews` | boolean | No | `true` | Scrape patient reviews for each doctor. |
| `maxReviewsPerDoctor` | integer | No | `50` | Max reviews saved per doctor (limited by what jameda server-renders on the page), 1–200. |
| `maxConcurrency` | integer | No | `20` | Pages fetched in parallel, 1–50. |
| `proxy` | object | No | Apify proxy off | Recommended for high concurrency. |

### Example Input

```json
{
  "specialty": "Hautarzt (Dermatologe)",
  "city": "Berlin",
  "specialties": ["Zahnarzt"],
  "cities": ["Hamburg"],
  "maxResults": 200,
  "includeReviews": true,
  "maxReviewsPerDoctor": 10
}
```

### Example Output (profile row)

```json
{
  "fullName": "Dr. med. Anna Schmidt",
  "professionalTitle": "Fachärztin für Dermatologie",
  "practiceName": "Hautärzte am Gendarmenmarkt",
  "city": "Berlin",
  "streets": ["Charlottenstraße 56, 10117 Berlin"],
  "phoneNumbers": ["+493020123456"],
  "web": ["https://www.example-praxis.de"],
  "openingHours": ["Mo–Fr 09:00–18:00"],
  "languages": ["Deutsch", "Englisch"],
  "insuranceTypes": ["GKV", "PKV"],
  "rating": 4.9,
  "reviewCount": 87,
  "specialties": ["Dermatologie"],
  "types": ["Facharzt"],
  "jamedaProfileUrl": "https://www.jameda.de/berlin/..."
}
```

#### Review row

`title`, `body`, `rating` (1–5), `secondaryRating`, `reviewAward`, `responseText`, `createdAt`.

### Verify Practice Data, Ratings & Opening Hours

Every field maps to jameda's public profile data: verified insurance types, exact opening hours, language skills and up-to-date ratings. The review count sits on each profile row, while full patient review text (where jameda allows display) lands in the reviews dataset.

### Integrations & Automation

- **Apify API** — feed profiles/reviews into CRM outreach, BI dashboards or ML pipelines.
- **Scheduling** — weekly reputation/rating monitoring per specialty or city.
- **Export** — JSON, CSV, Excel, HTML.

*Recommended schedule:* weekly for rating/review monitoring; monthly for full specialty×city sweeps or directory refreshes.

### Related Actors

- [Jameda Scraper – German Doctors](https://apify.com/giovannibiancia/Jameda) — jameda.de profiles and reviews (pay-per-specialty).
- [Jameda Scraper – Yazılım & Veri](https://apify.com/muhammetakkurtt/jameda-scraper) — jameda/znanylekarz data extraction by specialty and city.
- [Jameda Scraper – Doctor Data & Reviews](https://apify.com/benthepythondev/jameda-scraper) — jameda doctor profiles, ratings and reviews.
- [ZnanyLekarz Scraper – Polish Doctors](https://apify.com/giovannibiancia/ZnanyLekarz) — the Polish sister directory of the same group.

### FAQ

#### Why use this actor instead of a jameda API?

Jameda does not publish a public data API — their data is only available through the website and their own partner systems. Scraping the public pages is the standard way to get structured German healthcare directory data at scale. Unlike the larger per-doctor-priced competitors (from $0.027–$0.05 per doctor on the Apify Store), this actor's events are set by the publisher per profile and per review — you only pay for the rows actually extracted.

#### What are alternatives to this actor / German doctor data?

- [giovannibiancia/Jameda](https://apify.com/giovannibiancia/Jameda) — jameda profiles + reviews (from $0.05/doctor).
- [benthepythondev/jameda-scraper](https://apify.com/benthepythondev/jameda-scraper) — doctor data + reviews (from $0.027/doctor).
- Other German directories: Doctolib.de, Arzt-Auskunft (Stiftung Gesundheit), Sanego, Weisse Liste — different coverage per source.

#### How can I scrape several specialties and cities at once?

Put the main pair in `specialty` + `city` and the rest in the parallel `specialties` and `cities` arrays — every combination is crawled concurrently in the same run (all still capped by `maxResults`).

#### What is the best way to watch doctors' ratings?

Schedule a weekly run for the relevant specialty+city and read `rating`/`reviewCount` from each run's profile rows — your dataset builds a review history over time.

#### Why do my reviews stop at 50 per doctor?

`maxReviewsPerDoctor` defaults to 50 (max 200) and is limited by what jameda server-renders on the profile page; raise it and/or run more frequently to capture more reviews.

### SEO Keywords

jameda scraper, arzt daten deutschland, deutsche arztverzeichnis daten, arzt bewertungen scrapen, hautarzt berlin daten, zahnarzt daten export, arztpraxis lead generation, kassenarzt pkv gkv daten, jameda reviews dataset, doctor data germany, plus 49 arzt telefonnummern, sprechzeiten daten, healthtech data scraping, jameda api alternative, arztsuche daten

### For AI Agents & LLM Apps

- **Purpose:** given a German `specialty` and `city` (plus optional parallel `specialties`/`cities`), returns one row per jameda doctor profile (practice, address, +49 phone, insurance types, languages, opening hours, rating, review count) and, per profile, patient review rows in a separate reviews dataset.
- **Minimal input:**

```json
{ "specialty": "Hautarzt (Dermatologe)", "city": "Berlin", "maxResults": 50 }
```

- **Variant — reviews-heavy:**

```json
{ "specialty": "Zahnarzt", "city": "München", "maxResults": 20, "includeReviews": true, "maxReviewsPerDoctor": 25 }
```

- **Output field list (profiles dataset):** `fullName`, `professionalTitle`, `practiceName`, `city`, `streets`, `phoneNumbers`, `web`, `openingHours`, `languages`, `insuranceTypes`, `rating`, `reviewCount`, `specialties`, `types`, `jamedaProfileUrl`
- **Reviews dataset field list:** `title`, `body`, `rating`, `secondaryRating`, `reviewAward`, `responseText`, `createdAt`

Behaviors an agent should know:

- `specialty` and `city` are **required**; the parallel `specialties`/`cities` arrays only add combos to crawl concurrently.
- `maxResults` is the **global profile cap across all combos** (hard max 500) — set it deliberately or the run stops early.
- `includeReviews: false` skips the reviews dataset entirely and makes a run much faster/cheaper — use it for pure lead lists.
- `maxReviewsPerDoctor` is bounded by what jameda server-renders on the profile page (server-side, no pagination).
- Phone numbers are **normalized to +49** international format.
- **Billing:** pay-per-event — `profile` per doctor profile row, `review` per review row, + Actor Start ~$0.00005.

### Legal & Compliance Disclaimer

This actor is an independent tool and is not affiliated with, endorsed by, or sponsored by jameda (Docplanner Group). It accesses publicly available directory data at normal browsing volumes — no login bypass, no private data. The dataset contains personal and contact data of medical professionals (names, practice addresses, phone numbers, reviews); users are responsible for ensuring their use complies with applicable German and EU data-protection law (GDPR), jameda's Terms of Service, and any professional/healthcare regulations that apply to their intended use. This data should not be used for unsolicited commercial outreach in violation of applicable law.

# Actor input Schema

## `specialty` (type: `string`):

Medical specialty to search for, e.g. "Hautarzt (Dermatologe)", "Kardiologe", "Zahnarzt" or a jameda slug like "hautarzt-dermatologe".

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

German city to search in, e.g. "Berlin", "München", "Köln" or a slug like "muenchen".

## `specialties` (type: `array`):

Optional. Additional specialties to crawl IN PARALLEL in the same run (e.g. \["Kardiologe", "Zahnarzt"]). Combined with "cities", every specialty x city pair is crawled concurrently.

## `cities` (type: `array`):

Optional. Additional cities to crawl IN PARALLEL in the same run (e.g. \["Frankfurt", "Hamburg"]).

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

Maximum number of doctor profiles to scrape overall (across all specialty+city combinations, capped at 500).

## `maxPagesPerListing` (type: `integer`):

Maximum number of search-result listing pages to crawl per specialty+city (each page holds ~30 doctors).

## `includeReviews` (type: `boolean`):

Whether to scrape patient reviews for each doctor.

## `maxReviewsPerDoctor` (type: `integer`):

Maximum number of individual reviews to save per doctor (limited by what jameda server-renders on the profile page).

## `maxConcurrency` (type: `integer`):

Number of pages fetched in parallel. Higher = faster crawls (recommend the Apify proxy for high concurrency).

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

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "specialty": "Hautarzt (Dermatologe)",
  "city": "Berlin",
  "maxResults": 50,
  "maxPagesPerListing": 5,
  "includeReviews": true,
  "maxReviewsPerDoctor": 50,
  "maxConcurrency": 20,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

One row per doctor profile (default dataset).

## `reviewsDataset` (type: `string`):

One row per patient review in the aliased "reviews" dataset (always on when includeReviews is enabled). Found in the run's Storage tab.

# 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 = {
    "specialty": "Hautarzt (Dermatologe)",
    "city": "Berlin",
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/jameda-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 = {
    "specialty": "Hautarzt (Dermatologe)",
    "city": "Berlin",
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/jameda-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 '{
  "specialty": "Hautarzt (Dermatologe)",
  "city": "Berlin",
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call ahmed_jasarevic/jameda-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/jameda-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/w5wf3ldevLKnw6Fej/builds/of2hufghC10ncuVFX/openapi.json