MioDottore scraper API

Lead generation · v1.1.0 · miodottore_doctors

$0.001 / result

$1.00 / 1K · pay per delivered result

A MioDottore scraper API: name a specialty and an Italian comune — “Dentista”, “Monza” — and get one row per doctor or clinic. Each row carries the name, the specialty, star rating and review count, every practice address on the card, the first practice split into street, town, province and coordinates, and the price printed next to the first service.

By Aldo Morese, founder of QuanticData · Published Oct 4, 2026

Run in dashboard See the request

$0.001 per delivered result · $2 free every month · Failed runs never billed

What it does

What a MioDottore scraper API does

MioDottore is where Italian patients book private visits, so its listings are organised the way the market is: by specialty and by comune. The collector searches one specialty in one place and returns each professional or clinic as a typed row. The rating is a number, the practice addresses are an array, a paid placement is a boolean. A doctor who receives in three practices comes back once, with three addresses and practices_count set to three.

A maps listing gives you the building. This gives you the people who receive in it, and what they charge for the first listed service when the card prints it. Set include_phones and each row also carries the phone numbers, the facility name of every practice and the published price per service, read from the profile. A number that shows up on several rows of the same run is flagged in phone_shared_with, so a clinic switchboard is not mistaken for a direct line. The rows describe professionals and clinics in their public, professional capacity: no patient data is read, and reviews arrive as a count, not as text.

Inputs

The whole request. Anything you leave out falls back to the default shown in the catalog.

Input	Type	Required	What it does
`specialty`	string	yes	What to search for, as MioDottore names it — e.g. "Dentista", "Ortopedico", "Ginecologo", "Psicologo".
`location`	string	yes	Italian comune or city, e.g. "Milano", "Monza", "Roma".
`specialization_id`	string	no	MioDottore's own specialization id. Narrows a broad word to one specialty — 38 is Ortopedico. Optional.
`kind`	string	no	Professionals, facilities (clinics and poliambulatori), or both.
`include_phones`	boolean	no	Read each profile as well to add phones, per-practice facility names and published prices.
`country`	string	no	ISO 3166-1 alpha-2 code — proxy exit geo and Google locale (gl). Omit for the default pool.
`max_results`	integer	no	How many results to deliver at most (1–200). You pay only for delivered results.

Outputs — 29 fields, one row per result

What one result looks like

Every delivered result carries these fields. Nullable means the source did not publish it — the field stays empty instead of being guessed.

Field	Type	What it holds
`rank`	integer	1-based position in the listing order, featured placements first as the page renders them.
`entity_id`	string · nullable	MioDottore's own id for the professional or facility — the de-duplication key.
`entity_type`	string · nullable	"doctor" for a professional, "facility" for a clinic or poliambulatorio.
`name`	string	Name as listed: the professional, with title, or the clinic.
`url`	string · nullable	Profile URL on MioDottore.
`specialty`	string · nullable	Specialty as the card states it, e.g. "ortopedico".
`specialization_ids`	string[] · nullable	MioDottore specialization ids for the row — reusable as specialization_id to narrow a later search.
`rating`	number · nullable	Star rating out of 5.
`reviews`	integer · nullable	Number of patient opinions behind the rating.
`city`	string · nullable	City or cities of the practices, as the card lists them.
`addresses`	string[] · nullable	Every practice address on the card, in listing order.
`practices_count`	integer · nullable	How many practices the professional receives in.
`services`	string[] · nullable	Bookable services shown on the card.
`online_only`	boolean · nullable	True when the professional only offers remote visits — no practice to visit.
`sponsored`	boolean	True for paid placements (featured and fixed slots): real professionals and clinics, placed rather than matched.
`premium_profile`	boolean · nullable	True when the profile is a paid MioDottore profile (online booking enabled). Not a placement: organic results have it too.
`facility`	string · nullable	Name of the first practice on the card.
`street`	string · nullable	Street of the first practice.
`locality`	string · nullable	Town of the first practice.
`province`	string · nullable	Province code of the first practice (MB, MI, RM…).
`latitude`	number · nullable	Latitude of the first practice.
`longitude`	number · nullable	Longitude of the first practice.
`first_service_price`	number · nullable	Price in euro printed next to the first listed service, when the card shows one.
`online_payments`	boolean	True when the card carries the online-payments badge.
`phone`	string · nullable	First phone number from the profile. Null unless include_phones is set.
`phones`	string[] · nullable	All phone numbers on the profile. Null unless include_phones is set.
`phone_shared_with`	string · nullable	Set when a number also appears on other rows of the same run — a clinic switchboard rather than a direct practice line.
`practices`	object[] · nullable	Practices from the profile as { facility, address } — the facility name the listing does not carry. Null unless include_phones is set.
`prices`	object[] · nullable	Published prices as { service, price } in euro. Null unless include_phones is set.

Integration

One POST, typed rows

Base URL https://api.quanticdata.io/v1, Bearer auth, the same key as every other Data API. Endpoint: POST /v1/scraper/collectors/miodottore_doctors/run.

curl -X POST https://api.quanticdata.io/v1/scraper/collectors/miodottore_doctors/run \
  -H "Authorization: Bearer $QD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"specialty":"Dentista","location":"Monza","max_results":40}'

import requests

r = requests.post(
    "https://api.quanticdata.io/v1/scraper/collectors/miodottore_doctors/run",
    headers={"Authorization": f"Bearer {QD_API_KEY}"},
    json={
        "specialty": "Dentista",
        "location": "Monza",
        "max_results": 40
    },
    timeout=120,
)
for row in r.json()["payload"]["results"]:
    print(row)

const res = await fetch(
  "https://api.quanticdata.io/v1/scraper/collectors/miodottore_doctors/run",
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.QD_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"specialty":"Dentista","location":"Monza","max_results":40}),
  },
);
const { payload } = await res.json();
console.table(payload.results);

claude mcp add quanticdata \
  -e QUANTICDATA_API_KEY=qd_live_your_key_here \
  -- npx -y quanticdata-mcp

# then, in the chat:
> run the miodottore_doctors collector with specialty="Dentista" and location="Monza"

Example response

POST /v1/scraper/collectors/miodottore_doctors/run

$ curl $QD/miodottore_doctors/run \
    -H "Authorization: Bearer $QD_API_KEY" \
    -d '{"specialty": "Dentista", "location": "Monza", "max_results": 40}'
{ "status": "done", "count": 40,
  "results": [
    {
      "entity_type": "…",
      "name": "…",
      "specialty": "…",
      "city": "…" } ],
  "cost": 0.04 }
# 40 results × $0.001 · nothing delivered, nothing charged

Try it

MioDottore doctors and clinics, running now

Change the input and run it against the live collector — nothing to install, no sign-up.

Run it from your own code, on your own inputs

Same collector, same rows — $2 of free API credit every month, no card.

Get my free API key

MioDottore scraper API: from specialty and location, QuanticData reads the MioDottore page and returns one row per result with name, entity_type and specialty, at $0.001 per delivered result. — You send specialty and location; the listing comes back as results with rank, entity_id and name — 29 fields on every row — and you are billed $0.001 for each result actually delivered, nothing for a run that delivers none.

$0.001 / result2,000 results on the free $2 every month

Semantic inputspecialty, location, specialization_id — no URL lists

Up to 200results per run, pagination handled for you

29 fieldsone typed row per doctor or clinic

Pricing

MioDottore Scraper API pricing

$0.001 per delivered result. A run that delivers nothing costs nothing, and the $2 monthly allowance covers about 2,000 results before you spend anything.

$0.001per delivered result$1.00 per 1,000 delivered results

2,000 resultson the free allowance$2 every month, no card

Zero rowszero chargea run that delivers nothing is free

−30%on volume tiersthe catalog returns your key's price

Pay as you go

$0/mo

$2 free credit / month
60 requests / min
List unit prices

Starter

$19/mo

$15 free credit / month
300 requests / min
10% off unit prices

Growth

$79/mo

$50 free credit / month
600 requests / min
20% off unit prices

Scale

$299/mo

$250 free credit / month
1,200 requests / min
30% off unit prices

Same wallet, same key and same $2 monthly allowance as every other Data API. Prices are launch pricing read live from the billing config — GET /v1/scraper/collectors returns the price your key actually pays.

What people build with the MioDottore scraper API

Three shapes of work this endpoint was designed around.

Healthcare lead lists

Dentists, orthopaedists or psychologists in a comune, with practice addresses, province and — with include_phones — the numbers to call. The row a medical supplier or a software vendor starts from.

Market maps by specialty

How many professionals and clinics a specialty has in each town, who holds a paid placement and who has the reviews, keyed on entity_id so a re-run updates instead of duplicating.

Price benchmarks

The price of the first listed service on every card, and the full published price list per profile when you ask for it: what a first visit costs, by specialty and by city.

MioDottore Scraper API versus rolling your own

The differences that actually cost time when you build this in-house.

	DIY scraper	This collector
What you send	A search URL to build and paginate	A specialty and a comune
Practices	One address per card, the others behind tabs	Every practice address, and how many there are
Paid placements	Mixed into the list	Delivered and flagged `sponsored`
Shared phone numbers	Look like direct lines	Flagged in `phone_shared_with`
Billing	Requests, successful or not	Only delivered results

MioDottore scraper API: the POST to the miodottore_doctors collector, 40 results delivered and the bill, 40 × $0.001 = $0.04 in usage.cost_usd; zero results would cost $0. — The same call you would paste into a terminal: a Bearer key, specialty and location in the body, and back the envelope every QuanticData endpoint returns — type, message, payload — where count is how many results arrived and usage.cost_usd is $0.04, which is 40 × $0.001. A run that delivers nothing costs nothing.

Sources and standards

The platform documentation and standards this collector is built against — check any claim on this page against the primary source:

FAQ

Questions we get about the MioDottore scraper API.

Something else? Ask us

Does it return clinics as well as doctors?

Yes. kind chooses professionals, facilities (clinics and poliambulatori) or both, and every row says which it is in entity_type. The default is both.

How do I get phone numbers and prices?

Set include_phones. Each profile is then read as well, and the row gains phone, phones, the practices with their facility names and the published prices per service. Those runs are processed in the background: you get a run id and collect the rows when it finishes.

Are sponsored results included?

Yes, and they are labelled. Featured and fixed placements are real professionals and clinics, so they are delivered, with sponsored set to true. Filter on it if you want the organic list only.

Which places and specialties can I search?

Any Italian comune or city, and any specialty as MioDottore names it: Dentista, Ortopedico, Ginecologo, Psicologo. When a word is broad, specialization_id narrows it to one specialty, and each row returns its own specialization_ids for the next search.

Does it collect patient data?

No. The rows are the public listing of professionals and clinics: name, specialty, practices, rating and review count. Review text and anything about patients is not part of the output.

Is there a free MioDottore scraper API?

Every account gets $2 of credit every month with no card, which is about 2,000 delivered results on this endpoint at $0.001 each. It renews monthly, and a run that delivers nothing is never billed.

How much does one run cost?

Multiply the rows you actually receive by $0.001. A run capped at 200 results — the maximum for this collector — costs $0.2 if every row comes back, and less when the listing has fewer. Volume tiers take up to 30% off, and GET /v1/scraper/collectors returns the price your key actually pays.

Run the MioDottore scraper API now

$2 of free credit every month, no card. Your key returns its own prices from GET /v1/scraper/collectors.

Run in dashboard

Illustration: three coloured zones of the page that is read (MioDottore page) turn into clean JSON with the fields name, entity_type and specialty; 29 fields on every row.