# Jameda Doctor Extractor (`kawsar/jameda-doctor-extractor`) Actor

Jameda scraper that extracts doctor profiles, specializations, reviews, and coordinates from jameda.de, so you can build accurate provider directories without getting blocked.

- **URL**: https://apify.com/kawsar/jameda-doctor-extractor.md
- **Developed by:** [Kawsar](https://apify.com/kawsar) (community)
- **Categories:** Developer tools, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 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

## Jameda Doctor Extractor

Jameda Doctor Extractor is a professional, high-fidelity scraping agent built to harvest comprehensive physician, clinical, and healthcare provider directories from Germany's premier medical portal, **jameda.de**.

This high-performance scraping solution extracts complete provider profiles, medical specialties, patient ratings, feedback volume, and highly precise geographical coordinates (including physical address details and exact latitude/longitude GPS coordinates).

---

### 🌟 The Value of Jameda Data (Why Jameda?)

Jameda is the largest and most trusted healthcare review and search portal in Germany, housing detailed records for over 275,000 physicians, dentists, psychotherapists, and clinical practices. 

Scraping Jameda provides unparalleled advantages over general business registries:
- **Verified Medical Designations**: Access highly specialized medical titles, clinical sub-specialties, and focused designations that are rarely structured in standard business directories.
- **Patient-Driven Ratings & Sentiments**: Capture authentic patient feedback scores and aggregate recommendation counts representing direct public sentiment and local reputation.
- **Advanced Geo-Intelligence**: Extract coordinate-mapped practice locations which allow businesses to perform precise distance-based mapping and drive localized analysis.
- **Up-to-Date Medical Directory**: Unlike static governmental databases, Jameda’s records are continually updated by the practitioners and active patients, ensuring fresh, live listings.

---

### 📈 Key Business & Strategic Benefits

- **Market Density & Coverage Analysis**: Evaluate regional healthcare coverage, analyze localized physician density, and discover gaps in medical specialties across metropolitan and rural postal codes in Germany.
- **B2B Healthcare Lead Generation**: Build clean, highly targeted leads of specific medical practices, dental offices, and therapists for therapeutic, laboratory, or dental equipment supplies.
- **Competitive Benchmarking**: Track competitors' patient ratings, practice sizes, and service listings to analyze clinical positioning and market share in key cities.
- **Localized Directory Building**: Easily populate localized medical directory search apps, maps, or research platforms with structured, schema-compliant medical provider profiles.

---

### 🚀 Key Extractor Features

- **Smart Pagination Limits**: Set individual query-specific limit thresholds (`maxItemsPerQuery`) to perfectly control your runtime budget per search query or URL.
- **Automatic Keyword Cross-Matching**: Simply provide a list of medical queries (e.g. `Hausarzt`, `Zahnarzt`) and location regions or postcodes (e.g. `Berlin`, `80331`), and the extractor will automatically combine and crawl them.
- **Direct Search & Profile URL Processing**: Input direct links to pre-filtered search results or individual doctor profiles on Jameda to extract exact subsets.
- **Clean Schema Outputs**: Features a recursive, built-in data sanitizer that automatically cleans and strips missing elements (like missing review fields or coordinates) before pushing to your dataset, completely eliminating validation errors.
- **Highly Reliable Pagination**: Automatically navigates through search result pages to retrieve extensive datasets up to your exact limit per query.

---

### ⚙️ Configuration & Input Parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| **`queries`** | *Array of strings* | `["Internist"]` | List of specialties, doctor names, or symptoms to search. |
| **`locations`** | *Array of strings* | `["Berlin"]` | List of German cities, postal codes, or regions. |
| **`startUrls`** | *Array of objects* | `[]` | Direct search or profile URLs from the portal to process. |
| **`maxItemsPerQuery`** | *Integer* | `20` | Maximum records to extract per individual search query combination or start URL. |
| **`requestTimeoutSecs`** | *Integer* | `30` | Network request timeout per page in seconds. |

---

### 📊 Extracted Data Properties

Each record stored in your dataset represents a unique medical provider listing containing:

- `name` *(String)*: Full name of the medical professional, clinical team, or facility.
- `url` *(String - URI)*: Direct portal URL to the provider's profile.
- `imageUrl` *(String - URI)*: Practitioner's portrait photo or facility logo URL (when available).
- `specializations` *(Array of Strings)*: Extracted list of medical specialties and professional focus areas.
- `ratingScore` *(Number)*: Patient rating score out of 5.0.
- `reviewsCount` *(Integer)*: Total recommendation and patient review volume.
- `addresses` *(Array of Objects)*: List of address entries, with each object containing:
  - `addressId` *(String)*: Portal's internal address identifier.
  - `street` *(String)*: Street name and physical practice house number.
  - `city` *(String)*: Local city.
  - `region` *(String)*: Local region or federal state.
  - `entityName` *(String)*: Name of the practice office, healthcare group, or clinic.
  - `latitude` *(Number)*: Exact GPS latitude coordinate.
  - `longitude` *(Number)*: Exact GPS longitude coordinate.
- `scrapedAt` *(String - DateTime)*: ISO-8601 UTC timestamp of when the record was successfully scraped.

---

### 💾 Dataset Output Example

Here is a sample JSON record output from the dataset:

```json
{
  "name": "Dr. med. Philipp Lindemann",
  "url": "https://www.jameda.de/philipp-lindemann-2/allgemeinmediziner-hausarzt-internist-hausarzt/berlin",
  "imageUrl": "https://s3-eu-west-1.amazonaws.com/jamedade/doctor/80e029/80e02907cc779c05acb8962f13382db4_medium_square.jpg",
  "specializations": [
    "Internist",
    "Allgemeinmediziner",
    "Hausarzt"
  ],
  "ratingScore": 5.0,
  "reviewsCount": 126,
  "addresses": [
    {
      "addressId": "482583",
      "street": "Räuschstr. 57 a",
      "city": "Berlin",
      "region": "Berlin",
      "entityName": "Hausarztpraxis Dr.med. Philipp Lindemann Facharzt für Innere Medizin",
      "latitude": 52.583416,
      "longitude": 13.3012094
    }
  ],
  "scrapedAt": "2026-06-06T05:22:50.123456+00:00"
}
````

# Actor input Schema

## `queries` (type: `array`):

List of medical specialties, doctor names, or symptoms to search for (e.g. Internist, Zahnarzt).

## `locations` (type: `array`):

List of German cities, districts, or postal codes (e.g. Berlin, Hamburg).

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

List of direct Jameda search result URLs to scrape.

## `maxItemsPerQuery` (type: `integer`):

Maximum number of items to collect per search query or start URL.

## `requestTimeoutSecs` (type: `integer`):

Per-request timeout in seconds.

## Actor input object example

```json
{
  "queries": [
    "Internist"
  ],
  "locations": [
    "Berlin"
  ],
  "startUrls": [],
  "maxItemsPerQuery": 20,
  "requestTimeoutSecs": 30
}
```

# 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 = {
    "queries": [
        "Internist"
    ],
    "locations": [
        "Berlin"
    ],
    "startUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("kawsar/jameda-doctor-extractor").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 = {
    "queries": ["Internist"],
    "locations": ["Berlin"],
    "startUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("kawsar/jameda-doctor-extractor").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 '{
  "queries": [
    "Internist"
  ],
  "locations": [
    "Berlin"
  ],
  "startUrls": []
}' |
apify call kawsar/jameda-doctor-extractor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Jameda Doctor Extractor",
        "description": "Jameda scraper that extracts doctor profiles, specializations, reviews, and coordinates from jameda.de, so you can build accurate provider directories without getting blocked.",
        "version": "0.0",
        "x-build-id": "7IcKQLfnf8nQSOT8l"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/kawsar~jameda-doctor-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-kawsar-jameda-doctor-extractor",
                "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/kawsar~jameda-doctor-extractor/runs": {
            "post": {
                "operationId": "runs-sync-kawsar-jameda-doctor-extractor",
                "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/kawsar~jameda-doctor-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-kawsar-jameda-doctor-extractor",
                "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": [
                    "maxItemsPerQuery"
                ],
                "properties": {
                    "queries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "List of medical specialties, doctor names, or symptoms to search for (e.g. Internist, Zahnarzt).",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "Internist"
                        ]
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "List of German cities, districts, or postal codes (e.g. Berlin, Hamburg).",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "Berlin"
                        ]
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "List of direct Jameda search result URLs to scrape.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL",
                                    "description": "Direct Jameda search result or doctor profile URL."
                                }
                            }
                        },
                        "default": []
                    },
                    "maxItemsPerQuery": {
                        "title": "Max items per query/URL",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of items to collect per search query or start URL.",
                        "default": 20
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout (seconds)",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Per-request timeout in seconds.",
                        "default": 30
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```