# Wondel.ai MCP servers

> Wondel.ai hosts 26 remote MCP servers for flights, stays, maps, shopping, web search and the Polish web (Allegro, OLX, Otodom, NBP). Connect to https://mcp.wondel.ai/<id>/mcp over Streamable HTTP with no auth; human docs at https://mcps.wondel.ai.

Connect: point any MCP client at `https://mcp.wondel.ai/<id>/mcp` (Streamable HTTP, no auth). Not sure which server? Connect to `https://mcp.wondel.ai/mcp` and call `list_servers`.
Machine-readable: [AI Catalog](https://mcp.wondel.ai/.well-known/ai-catalog.json), [routing index](https://mcp.wondel.ai/catalog.json), [full tool reference](https://mcp.wondel.ai/llms-full.txt), [agent skill](https://mcp.wondel.ai/.well-known/agent-skills/wondel-mcps/SKILL.md), [auth.md](https://mcp.wondel.ai/auth.md).

## Legal notice
- Unofficial, experimental servers run by Wondel.ai, free of charge; not affiliated with or endorsed by any source site.
- Data is fetched on demand from third-party sites and official APIs. Copyright, database rights and trademarks stay with the source operators; nothing here grants a licence.
- Intended for personal use (looking something up for yourself through an assistant), plus testing, research and demonstration of MCP integrations. Not for bulk querying, redistribution, competing databases or training datasets.
- Attribute results to their source and keep the original links. Data may be stale or wrong; verify at the source before deciding. Provided as-is, without warranty.
- Rights holders and site operators: write to support@wondel.ai and the server is withdrawn promptly (it then answers HTTP 451). The same address takes reports of inaccurate data and personal-data removal requests.
- Full terms, Polish binding with an English translation: https://mcp.wondel.ai/legal.txt
## Allegro MCP

Endpoint: https://mcp.wondel.ai/allegro/mcp
Live offers on Allegro.pl: search, browse a category, fetch one offer.
Latency: ~30–120 s, live stealth-browser scrape via unblocker chain; results with offers cached 10 min
Docs: https://mcps.wondel.ai/servers/allegro/
Source: Allegro.pl (https://allegro.pl)

### allegro_search

Search live Allegro.pl marketplace offers by phrase, with optional price range, condition and sort. Returns titles, prices, sellers and offer URLs. Data is scraped live via a stealth browser, so a call may take ~30–120s. Result shape: { source, fetchedAt, query, count, offers: [...], note } — the list key is `offers`, never `items` or `results`. Each offer: { title, price, currency, url, seller, condition, imageUrl }; `price` is the formatted string Allegro renders (e.g. "3 499,00"), not a number.

Parameters:
- `phrase` (string, required): Search text, e.g. 'iphone 15 128gb'
- `sort` (string): Result ordering (default: relevance) One of: relevance, price-asc, price-desc, newest, popularity.
- `priceFrom` (number): Minimum price in PLN
- `priceTo` (number): Maximum price in PLN
- `condition` (string): Item condition filter One of: new, used.
- `limit` (integer): Max offers to return (default 24)

### allegro_browse_category

Browse live Allegro.pl offers within a category (by Allegro category id or full category URL), with the same filters as allegro_search. Data is scraped live via a stealth browser, so a call may take ~30–120s.

Parameters:
- `category` (string, required): Allegro category id or full https://allegro.pl/kategoria/... URL
- `phrase` (string): Optional search text within the category
- `sort` (string): Result ordering (default: relevance) One of: relevance, price-asc, price-desc, newest, popularity.
- `priceFrom` (number): Minimum price in PLN
- `priceTo` (number): Maximum price in PLN
- `condition` (string): Item condition filter One of: new, used.
- `limit` (integer): Max offers to return (default 24)

### allegro_get_offer

Fetch details of a single Allegro.pl offer by id or URL (title, price, seller, condition, description summary, parameters, images). Data is scraped live via a stealth browser, so a call may take ~30–120s.

Parameters:
- `offerId` (string, required): Allegro offer id (numeric) or full https://allegro.pl/oferta/... URL

## Ceneo MCP

Endpoint: https://mcp.wondel.ai/ceneo/mcp
Price comparison on Ceneo.pl: search products, list every shop's offer, fetch product details.
Latency: ~3–20 s, HTML scrape via unblocker chain (forced in prod)
Docs: https://mcps.wondel.ai/servers/ceneo/
Source: Ceneo.pl (https://www.ceneo.pl)

### ceneo_search

Search Ceneo.pl (Poland's price-comparison engine) by phrase. Returns each product's lowest price and how many shops offer it, plus its Ceneo product id (use it with ceneo_product_offers). Fetched live from Ceneo.pl (a few seconds via direct fetch; up to ~20s when routed through an unblocker backend). Result shape: { source, fetchedAt, query, count, products: [...], note? } — the list key is `products`, and there are no per-shop offers here (call ceneo_product_offers with a product `id` for those). Each product: { id, name, url, lowestPrice, currency, shopCount, image }; `lowestPrice` is the formatted string Ceneo renders, not a number. A genuine no-match answers count: 0 with a `note` saying what to try instead — that is a successful result, not an error.

Parameters:
- `phrase` (string, required): Search text, e.g. 'iphone 15 128gb'
- `limit` (integer): Max products to return (default 24)

### ceneo_product_offers

Given a Ceneo product id, return EVERY shop's offer (shop, price, link) sorted cheapest-first — the price comparison. Get the id from ceneo_search. Fetched live from Ceneo.pl (a few seconds via direct fetch; up to ~20s when routed through an unblocker backend).

Parameters:
- `productId` (string, required): Ceneo product id (digits) or full https://www.ceneo.pl/<id> URL

### ceneo_product

Product details from Ceneo: name, images, description, brand, price range, offer count and rating. Fetched live from Ceneo.pl (a few seconds via direct fetch; up to ~20s when routed through an unblocker backend).

Parameters:
- `productId` (string, required): Ceneo product id (digits) or full product URL

## Google Flights MCP

Endpoint: https://mcp.wondel.ai/google-flights/mcp
Live Google Flights fares: search routes, discover cheap deals from an origin.
Latency: ~2–8 s via SerpAPI
Docs: https://mcps.wondel.ai/servers/google-flights/
Source: Google Flights (https://www.google.com/travel/flights)

### google_flights_search

Search Google Flights live via SerpAPI. Returns best_flights and other_flights (each with legs, airlines, times, duration, layovers, price and carbon emissions), plus price_insights and airport info. Supports round trip (type=1, needs return_date), one way (type=2) and multi-city (type=3 via multi_city_json). Two-step flows: pass a departure_token from a prior result to get the returning flights / next leg, or a booking_token to get booking options — re-send the original search params alongside either token. Prices are in `currency` (default USD). IDs are AIRPORT codes, never city/metro codes: TYO, NYC, LON, PAR, MIL, ROM, OSA, CHI, WAS return NO results (live-verified) — send the airports instead (TYO → 'HND,NRT'; NYC → 'JFK,EWR,LGA'; LON → 'LHR,LGW,STN,LTN'; PAR → 'CDG,ORY'; MIL → 'MXP,LIN,BGY'; ROM → 'FCO,CIA') or the city's Google kgmid (e.g. '/m/07dfk' for Tokyo). Result shape: { note?, source, fetchedAt, query, search_metadata: { google_flights_url }, search_parameters, best_flights: [...], other_flights: [...], price_insights, airports } — the two itinerary lists are `best_flights` and `other_flights` (there is no `flights` or `deals` key at the top level, and an itinerary is never a bare flight). Each itinerary: { flights: [{ departure_airport: { name, id, time }, arrival_airport: { name, id, time }, duration, airplane, airline, airline_logo, travel_class, flight_number, legroom, extensions }], layovers: [{ duration, name, id, overnight }], total_duration, carbon_emissions, price, type, airline_logo, departure_token, booking_token } — `price` is the whole-itinerary price in `currency`, `duration`/`total_duration` are minutes, and the per-leg times are local 'YYYY-MM-DD HH:MM' strings. Feed `departure_token` back for the return leg and `booking_token` for booking options. A top-level `note` appears only when stops=1 found no nonstop flight and the server retried without the stop filter: the itineraries are then connecting flights, and their tokens need the same params re-sent without `stops` — tell the user that no direct flights were found and connecting flights are shown.

Parameters:
- `gl` (string): Country code for the search, e.g. 'us', 'uk', 'de'.
- `hl` (string): Language code, e.g. 'en', 'es', 'fr'.
- `currency` (string): Currency of returned prices (ISO code, e.g. 'USD', 'EUR'). Default USD.
- `departure_id` (string): Departure AIRPORT IATA code(s) (3-letter, uppercase, e.g. 'WAW' or 'WAW,WMI') or a Google location kgmid (/m/… or /g/…). Comma-separate multiple. NOT a city/metro code — TYO, NYC, LON, PAR, MIL, ROM return no results; list the airports instead (NYC → 'JFK,EWR,LGA'). Used for type 1/2; for multi-city (type 3) use multi_city_json instead.
- `arrival_id` (string): Arrival AIRPORT IATA code(s) (e.g. 'HND,NRT') or a Google location kgmid (e.g. '/m/07dfk' for Tokyo). Comma-separate multiple. NOT a city/metro code — TYO, LON, PAR, MIL, ROM, OSA return no results; list the airports instead.
- `outbound_date` (string): Outbound date, YYYY-MM-DD.
- `return_date` (string): Return date, YYYY-MM-DD. Required when type=1 (round trip).
- `type` (integer): Trip type: 1 = round trip (default), 2 = one way, 3 = multi-city.
- `travel_class` (integer): Travel class: 1 = economy (default), 2 = premium economy, 3 = business, 4 = first.
- `sort_by` (integer): Sort order: 1 = top flights (default), 2 = price, 3 = departure time, 4 = arrival time, 5 = duration, 6 = emissions.
- `multi_city_json` (string): Multi-city itinerary (required when type=3): a JSON-string array of legs, e.g. '[{"departure_id":"CDG","arrival_id":"NRT","date":"2026-06-27"},{"departure_id":"NRT","arrival_id":"LAX","date":"2026-07-03"}]'. Each leg may include an optional "times" field (same format as outbound_times).
- `show_hidden` (boolean): Include hidden flight results. Default false.
- `exclude_basic` (boolean): Exclude basic-economy fares. Only for domestic US flights with travel_class=1. Default false.
- `deep_search` (boolean): Run a deeper search that matches the Google Flights browser results more closely (slower). Default false.
- `adults` (integer): Number of adults. Default 1.
- `children` (integer): Number of children. Default 0.
- `infants_in_seat` (integer): Number of infants in seat. Default 0.
- `infants_on_lap` (integer): Number of infants on lap. Default 0.
- `stops` (integer): Max stops: 0 = any (default), 1 = nonstop only, 2 = 1 stop or fewer, 3 = 2 stops or fewer. When stops=1 finds no nonstop flight, the server automatically retries without the filter and returns connecting flights with a `note`; send a departure_token/booking_token from those with the same params but no stops.
- `include_airlines` (string): Only these airlines: comma-separated 2-letter IATA codes, or an alliance: STAR_ALLIANCE, SKYTEAM, ONEWORLD. Mutually exclusive with exclude_airlines.
- `exclude_airlines` (string): Exclude these airlines: comma-separated 2-letter IATA codes, or an alliance (STAR_ALLIANCE, SKYTEAM, ONEWORLD). Mutually exclusive with include_airlines.
- `bags` (integer): Number of carry-on bags. Default 0.
- `max_price` (integer): Maximum ticket price in the selected currency.
- `outbound_times` (string): Outbound time window as comma-separated hours (0-23). 2 values = departure range 'min,max' (e.g. '4,18'); 4 values add an arrival range (e.g. '4,18,3,19').
- `return_times` (string): Return time window, same format as outbound_times. Only valid when type=1.
- `emissions` (integer): Emissions filter: 1 = less emissions only. Omit for no filter.
- `layover_duration` (string): Layover duration range in minutes, 'min,max' (e.g. '90,330' for 1.5-5.5h).
- `exclude_conns` (string): Connecting airports to exclude: comma-separated 3-letter IATA codes (e.g. 'CDG,LHR').
- `max_duration` (integer): Maximum total trip duration in minutes (e.g. 1500 for 25h).
- `departure_token` (string): Token from a prior result, used to select an outbound flight and fetch the returning flights (round trip) or the next leg (multi-city). Re-send the same search params alongside it. Mutually exclusive with booking_token.
- `booking_token` (string): Token from a prior result, used to fetch booking options for a selected itinerary. Re-send the same search params alongside it. Mutually exclusive with departure_token.
- `no_cache` (boolean): Force a fresh SerpAPI fetch and bypass this server's result cache. Default false.
- `zero_trace` (boolean): Enterprise-only ZeroTrace mode: don't store search params/metadata on SerpAPI. Default false.

### google_flights_deals_search

Discover cheap flight destinations from an origin via SerpAPI's Google Flights Deals engine (google_flights_deals). Unlike google_flights_search there is no arrival_id — the engine explores destinations for you — and there are no pagination or navigation tokens. Dates accept a single YYYY-MM-DD or a 'start,end' range (e.g. '2026-06-27,2026-07-03') to widen the window. Supports round trip (type=1, needs return_date) and one way (type=2). Prices are in `currency` (default USD). Result shape: { source, fetchedAt, query, search_metadata, search_parameters, departure_informations, deals: [...] } — the list key is `deals` (there are no best_flights/other_flights here). Each deal: { destination_id, name, country, price, average_price, discount_percentage, flight_link, serpapi_flight_link, thumbnail, outbound_date, return_date, departure_airport_code, arrival_airport_code, flight_duration, stops, airline, airline_code, description, highlights }. The dates are `outbound_date` / `return_date` (YYYY-MM-DD) — the live engine returns those, not the `start_date`/`end_date` of SerpAPI's docs — and a deal carries NO departure or return time.

Parameters:
- `departure_id` (string): Departure AIRPORT IATA code(s) (3-letter, uppercase, e.g. 'WAW' or 'WAW,WMI') or a Google location kgmid (/m/… or /g/…). Comma-separate multiple. NOT a city/metro code (NYC, LON, PAR return no results — list the airports). No arrival_id: the deals engine discovers destinations for you.
- `gl` (string): Country code for the search, e.g. 'us', 'uk', 'de'.
- `hl` (string): Language code, e.g. 'en', 'es', 'fr'.
- `currency` (string): Currency of returned prices (ISO code, e.g. 'USD', 'EUR'). Default USD.
- `type` (integer): Trip type: 1 = round trip (default, needs return_date), 2 = one way.
- `travel_class` (integer): Travel class: 1 = economy (default), 2 = premium economy, 3 = business, 4 = first.
- `outbound_date` (string): Outbound date as a single YYYY-MM-DD, or a 'start,end' range (e.g. '2026-06-27,2026-07-03') to search a window.
- `return_date` (string): Return date as a single YYYY-MM-DD, or a 'start,end' range. Required when type=1 (round trip). When outbound_date is a range it must be a 'start,end' range too (or drop it and use trip_length/travel_duration).
- `travel_duration` (integer): Travel duration preset: 1 = one week, 2 = weekend, 3 = two weeks.
- `trip_length` (integer|string): Trip length in days: a single number, or a 'min,max' day range (e.g. '3,5').
- `adults` (integer): Number of adults. Default 1.
- `children` (integer): Number of children. Default 0.
- `infants_in_seat` (integer): Number of infants in seat. Default 0.
- `infants_on_lap` (integer): Number of infants on lap. Default 0.
- `stops` (integer): Max stops: 0 = any (default), 1 = nonstop only, 2 = 1 stop or fewer, 3 = 2 stops or fewer.
- `include_airlines` (string): Only these airlines: comma-separated 2-letter IATA codes, or an alliance: STAR_ALLIANCE, SKYTEAM, ONEWORLD. Mutually exclusive with exclude_airlines.
- `exclude_airlines` (string): Exclude these airlines: comma-separated 2-letter IATA codes, or an alliance (STAR_ALLIANCE, SKYTEAM, ONEWORLD). Mutually exclusive with include_airlines.
- `max_price` (integer): Maximum ticket price in the selected currency.
- `max_duration` (integer): Maximum total trip duration in minutes (e.g. 1500 for 25h).
- `no_cache` (boolean): Force a fresh SerpAPI fetch and bypass this server's result cache. Default false.
- `zero_trace` (boolean): Enterprise-only ZeroTrace mode: don't store search params/metadata on SerpAPI. Default false.

## Google Hotels MCP

Endpoint: https://mcp.wondel.ai/google-hotels/mcp
Live Google Hotels search: properties with rates and ratings, plus photos and reviews.
Latency: ~2–8 s via SerpAPI
Docs: https://mcps.wondel.ai/servers/google-hotels/
Source: Google Hotels (https://www.google.com/travel/hotels)

### google_hotels_search

Search Google Hotels live via SerpAPI. Returns properties (hotels and, with vacation_rentals, rentals) with names, prices/rates, overall ratings, review counts, amenities, images and location, plus the brands/property_types/amenities filter ids you can feed back in. Requires q (a destination, area or hotel name), check_in_date and check_out_date (YYYY-MM-DD). Every property in the results carries a `property_token`: pass it back here (keeping the same check_in_date/check_out_date) to get that one property's full details, or hand it to google_hotels_photos and google_hotels_reviews. Paginate with next_page_token. Prices are in `currency` (default USD). Result shape: { source, fetchedAt, query, search_metadata, search_parameters, search_information, brands, ads, properties: [...], serpapi_pagination } — the list key is `properties` (ads are separate). Each property: { type, name, property_token, link, gps_coordinates, rate_per_night: { lowest, extracted_lowest }, total_rate, prices: [{ source, num_guests, rate_per_night }], overall_rating, reviews, hotel_class (label), extracted_hotel_class (number), amenities, images: [{ thumbnail, original_image }], nearby_places, description }. With property_token the single property's fields come back at the top level instead of `properties`.

Parameters:
- `q` (string, required): Search query: a destination, area, or hotel name (e.g. 'Bali resorts', 'hotels in Paris').
- `check_in_date` (string, required): Check-in date, YYYY-MM-DD.
- `check_out_date` (string, required): Check-out date, YYYY-MM-DD.
- `gl` (string): Country code for the search, e.g. 'us', 'uk', 'de'.
- `hl` (string): Language code, e.g. 'en', 'es', 'pt-br'.
- `currency` (string): Currency of returned prices (ISO code, e.g. 'USD', 'EUR'). Default USD.
- `adults` (integer): Number of adults. Default 2.
- `children` (integer): Number of children. Default 0.
- `children_ages` (string): Ages of the children as comma-separated values, e.g. '5,8'. Each age 1-17; the count should match `children`.
- `sort_by` (integer): Sort order: 3 = lowest price, 8 = highest rating, 13 = most reviewed. Omit for SerpAPI's default relevance ranking.
- `min_price` (integer): Minimum price per night in the selected currency.
- `max_price` (integer): Maximum price per night in the selected currency.
- `rating` (integer): Minimum overall rating: 7 = 3.5+, 8 = 4.0+, 9 = 4.5+.
- `property_types` (string): Filter by property type: comma-separated type ids (see property_types in a prior response).
- `amenities` (string): Filter by amenities: comma-separated amenity ids (see amenities in a prior response).
- `hotel_class` (string): Filter by hotel class (stars): comma-separated values from 2 to 5, e.g. '4,5'.
- `brands` (string): Filter by hotel brand: comma-separated brand ids (see brands in a prior response). Not applicable to vacation rentals.
- `free_cancellation` (boolean): Only show properties offering free cancellation. Default false.
- `special_offers` (boolean): Only show properties with special offers. Default false.
- `eco_certified` (boolean): Only show eco-certified properties. Default false.
- `vacation_rentals` (boolean): Search vacation rentals instead of hotels. Default false (hotels).
- `bedrooms` (integer): Minimum number of bedrooms. Vacation rentals only. Default 0.
- `bathrooms` (integer): Minimum number of bathrooms. Vacation rentals only. Default 0.
- `property_token` (string): Token for a single property from a prior search result; returns that property's full details. Still pass check_in_date and check_out_date.
- `next_page_token` (string): Token from a prior response to fetch the next page of results.
- `no_cache` (boolean): Force a fresh SerpAPI fetch and bypass this server's result cache. Default false.
- `zero_trace` (boolean): Enterprise-only ZeroTrace mode: don't store search params/metadata on SerpAPI. Default false.

### google_hotels_photos

Fetch the full set of photos for a single Google Hotels property via SerpAPI. Requires a `property_token` taken from a google_hotels_search result. Paginate with next_page_token.

Parameters:
- `property_token` (string, required): Property token from a google_hotels_search result identifying the property whose photos to fetch.
- `next_page_token` (string): Token from a prior response to fetch the next page of photos.
- `no_cache` (boolean): Force a fresh SerpAPI fetch and bypass this server's result cache. Default false.
- `zero_trace` (boolean): Enterprise-only ZeroTrace mode: don't store search params/metadata on SerpAPI. Default false.

### google_hotels_reviews

Fetch reviews for a single Google Hotels property via SerpAPI. Requires a `property_token` taken from a google_hotels_search result. Filter by category_token or source_number, order with sort_by, and paginate with next_page_token.

Parameters:
- `property_token` (string, required): Property token from a google_hotels_search result identifying the property whose reviews to fetch.
- `hl` (string): Language code, e.g. 'en', 'es', 'pt-br'.
- `category_token` (string): Token to filter reviews by a category/topic (from a prior reviews response).
- `sort_by` (integer): Sort order: 1 = most helpful, 2 = most recent, 3 = highest rating, 4 = lowest rating.
- `source_number` (integer): Filter reviews by a specific review source (provider) number, as listed in a prior response.
- `next_page_token` (string): Token from a prior response to fetch the next page of reviews.
- `no_cache` (boolean): Force a fresh SerpAPI fetch and bypass this server's result cache. Default false.
- `zero_trace` (boolean): Enterprise-only ZeroTrace mode: don't store search params/metadata on SerpAPI. Default false.

## Google Maps MCP

Endpoint: https://mcp.wondel.ai/google-maps/mcp
Google Maps places: local search, place details, reviews, and turn-by-turn directions.
Latency: ~2–8 s via SerpAPI
Docs: https://mcps.wondel.ai/servers/google-maps/
Source: Google Maps (https://maps.google.com)

### google_local_search

Search the Google Local pack via SerpAPI — the local business listings Google shows for a query. Returns local_results, each with title, rating, reviews, type, address, phone and the place identifiers (place_id / data_id / data_cid) that feed google_maps_reviews. Provide a query q and optionally a location (or a pre-encoded uule). Paginate with start (+20 per page).

Parameters:
- `q` (string, required): Search query, e.g. 'Coffee' or 'Pizza near Central Park'.
- `location` (string): Geographic origin of the search — a SerpAPI canonical city-level name, e.g. 'Warsaw,Masovian Voivodeship,Poland'. For a small town or a district, put the place in q instead. Mutually exclusive with uule.
- `uule` (string): Google-encoded location string (an alternative to location). Mutually exclusive with location.
- `google_domain` (string): Google domain to use, e.g. 'google.com', 'google.co.uk'.
- `gl` (string): Country code for the search, e.g. 'us', 'uk', 'de'.
- `hl` (string): Language code, e.g. 'en', 'es', 'fr', 'pt-br'.
- `ludocid` (string): Google CID of a business listing, to scope results to that place.
- `tbs` (string): Advanced search parameters not otherwise supported, passed through as a raw tbs string.
- `start` (integer): Result offset for pagination (0-based); ~20 results per page, so use 20, 40, ….
- `device` (string): Device to emulate: 'desktop' (default), 'tablet' or 'mobile'. One of: desktop, tablet, mobile.
- `no_cache` (boolean): Force a fresh SerpAPI fetch and bypass this server's result cache. Default false.
- `zero_trace` (boolean): Enterprise-only ZeroTrace mode: don't store search params/metadata on SerpAPI. Default false.

### google_maps_search

Search Google Maps via SerpAPI. type=search (default) returns a list of places for a query q — paginate with start (+20 per page). type=place returns the full details of a single place identified by place_id or data_cid (both obtainable from a prior search result). Center the map with ll ('@lat,lon,zoomz') or lat/lon/z. The place_id / data_cid in results feed google_maps_reviews.

Parameters:
- `q` (string): Search query, e.g. 'Coffee' or 'Restaurants'. Required for a search (type=search) unless place_id/data_cid is given.
- `type` (string): 'search' (default) returns a list of places for q; 'place' returns details for a single place (requires place_id or data_cid). One of: search, place.
- `ll` (string): Map center as '@lat,lon,zoomz' (latitude, longitude, zoom), e.g. '@40.7455096,-74.0083012,14z'. Zoom recommended 3z-15z.
- `location` (string): Geographic origin of the search — a SerpAPI canonical city-level name, e.g. 'Warsaw,Masovian Voivodeship,Poland'. For a small town or a district, put the place in q instead. SerpAPI requires z or m alongside it — z defaults to 14 when neither is given.
- `lat` (number): Latitude of the map center (used with lon; alternative to ll).
- `lon` (number): Longitude of the map center (used with lat; alternative to ll).
- `z` (integer): Map zoom level, 3-30 (higher = more zoomed in). Used with lat/lon or location; defaults to 14 when either is given without z or m.
- `m` (integer): Alternative map scale parameter, 1-15028132 (an alternative to the zoom level).
- `nearby` (boolean): Search nearby the given coordinates. Default false.
- `place_id` (string): Google Maps place_id of a specific place — an opaque string like 'ChIJ…' from a google_maps_search result. A digit-only id is a Google CID (what google_local_search calls place_id) and is sent as data_cid automatically. Use with type=place; also feeds google_maps_reviews.
- `data_cid` (string): Google Maps CID (data_cid) of a specific place (from a prior search result). Use with type=place; also feeds google_maps_reviews.
- `google_domain` (string): Google domain to use, e.g. 'google.com'.
- `hl` (string): Language code, e.g. 'en', 'es', 'fr', 'pt-br'.
- `gl` (string): Country code for the search, e.g. 'us', 'uk', 'de'.
- `min_price` (integer): Minimum price-level filter for places.
- `max_price` (integer): Maximum price-level filter for places.
- `min_rating` (string): Minimum star-rating filter. Must be a string like '4.0' (a number such as 4.0 stringifies to '4' and breaks the filter). One of: 2.0, 2.5, 3.0, 3.5, 4.0, 4.5.
- `open_state` (string): Open-state filter: 'now' = open now, '24h' = open 24 hours. Mutually exclusive with open_on_day/open_at_hour. One of: now, 24h.
- `open_on_day` (string): Filter to places open on a given day (mon-sun). Combine with open_at_hour. Mutually exclusive with open_state. One of: mon, tue, wed, thu, fri, sat, sun.
- `open_at_hour` (integer): Filter to places open at a given hour, 0-23. Use with open_on_day. Mutually exclusive with open_state.
- `start` (integer): Result offset for pagination (0-based); 20 results per page, so use 20, 40, ….
- `no_cache` (boolean): Force a fresh SerpAPI fetch and bypass this server's result cache. Default false.
- `zero_trace` (boolean): Enterprise-only ZeroTrace mode: don't store search params/metadata on SerpAPI. Default false.

### google_maps_reviews

Fetch the reviews of a Google Maps place via SerpAPI. Provide exactly one of place_id, data_id or data_cid — all come from google_maps_search or google_local_search results. A digit-only id (the `place_id` that google_local_search returns is a Google CID) is accepted in any of the three fields and resolved to the Maps data_id automatically via one place lookup. Returns reviews (author, rating, text, date) plus the topics you can filter by. Paginate with next_page_token from the previous response.

Parameters:
- `place_id` (string): Google Maps place_id of the place ('ChIJ…' from google_maps_search). A digit-only value is treated as a Google CID and resolved automatically. Provide exactly one of place_id, data_id or data_cid.
- `data_id` (string): Google Maps data_id of the place ('0x…:0x…' from google_maps_search). Provide exactly one of place_id, data_id or data_cid.
- `data_cid` (string): Google CID of the place — the digit-only `place_id` google_local_search returns. Resolved to the Maps data_id via one place lookup. Provide exactly one of place_id, data_id or data_cid.
- `hl` (string): Language code, e.g. 'en', 'es', 'fr', 'pt-br'.
- `sort_by` (string): Review sort order: 'qualityScore' (most relevant, default), 'newestFirst', 'ratingHigh', 'ratingLow'. One of: qualityScore, newestFirst, ratingHigh, ratingLow.
- `topic_id` (string): Filter reviews by a topic id (from a prior response). Mutually exclusive with query.
- `query` (string): Filter/search reviews by free text. Mutually exclusive with topic_id.
- `num` (integer): Number of reviews per page, 1-20 — only honoured together with next_page_token, topic_id or query; the initial page always returns 8 and the parameter is dropped there.
- `next_page_token` (string): Pagination token from the previous response, to fetch the next page of reviews.
- `no_cache` (boolean): Force a fresh SerpAPI fetch and bypass this server's result cache. Default false.
- `zero_trace` (boolean): Enterprise-only ZeroTrace mode: don't store search params/metadata on SerpAPI. Default false.

### google_maps_directions

Get directions between two points via SerpAPI. Provide a start point (one of start_addr, start_coords 'lat,lon', or start_data_id) and an end point (one of end_addr, end_coords, or end_data_id) — the data_ids come from google_maps_search results. Returns the route(s) with distance, duration and step-by-step legs. Shape the route with travel_mode (driving/transit/walking/…), avoid, and time. Result shape: { source, fetchedAt, query, search_metadata, search_parameters, places_info: [{ address, data_id, gps_coordinates }], durations: [{ travel_mode, duration, formatted_duration }], directions: [...] } — the list key is `directions`. Each direction: { travel_mode, via, distance (meters), duration (seconds), formatted_distance, formatted_duration, typical_duration_range, extensions, trips: [{ travel_mode, title, distance, duration, formatted_distance, formatted_duration, details: [{ title, action, distance, duration }] }] } plus, for transit, start_time, end_time, arrive_around, cost, currency; a Flight entry has only { travel_mode, icon, flight }.

Parameters:
- `start_addr` (string): Starting address, e.g. 'Austin, TX'. Provide one of start_addr/start_coords/start_data_id.
- `start_coords` (string): Starting GPS coordinates as 'lat,lon', e.g. '30.1974,-97.6663'.
- `start_data_id` (string): Place data id of the starting point (from a google_maps_search result).
- `end_addr` (string): Ending address, e.g. 'Dallas, TX'. Provide one of end_addr/end_coords/end_data_id.
- `end_coords` (string): Ending GPS coordinates as 'lat,lon'.
- `end_data_id` (string): Place data id of the ending point (from a google_maps_search result).
- `travel_mode` (number): Travel mode: 6=Best (default), 0=Driving, 1=Cycling, 2=Walking, 3=Transit, 4=Flight, 9=Two-wheeler.
- `distance_unit` (number): Distance unit: 0=km, 1=miles.
- `avoid` (string): Comma-separated route features to avoid: 'highways', 'tolls', 'ferries'.
- `prefer` (string): Comma-separated transit preferences (travel_mode=3 only): 'bus', 'subway', 'train', 'tram_light_rail'.
- `route` (number): Transit route option (travel_mode=3 only): 2=Fewer transfers, 3=Less walking, 4=Wheelchair accessible.
- `time` (string): Departure/arrival time: 'depart_at:<unix>', 'arrive_by:<unix>', or 'last_available' (transit only).
- `gl` (string): Country code, e.g. 'us', 'uk', 'de'.
- `hl` (string): Language code, e.g. 'en', 'es', 'fr'.
- `no_cache` (boolean): Force a fresh SerpAPI fetch and bypass this server's result cache. Default false.
- `zero_trace` (boolean): Enterprise-only ZeroTrace mode: don't store search params/metadata on SerpAPI. Default false.

## Google Shopping MCP

Endpoint: https://mcp.wondel.ai/google-shopping/mcp
Google Shopping product search: listings with prices, merchants and ratings.
Latency: ~2–8 s via SerpAPI
Docs: https://mcps.wondel.ai/servers/google-shopping/
Source: Google Shopping (https://shopping.google.com)

### google_shopping_search

Search Google Shopping live via SerpAPI. Returns shopping_results (product listings with title, price, merchant/source, rating, reviews, shipping and product/offer links) plus filters and related results. Set light=true to use the faster google_shopping_light engine (lower latency, but the response omits filters/carousel_filters and it misses some products the full engine finds — an empty light answer is retried once on the full engine; the result's `source` and `note` say so). `q` is required unless you pass a `shoprs` refinement token from a prior result. Prices reflect the chosen gl/locale.

Parameters:
- `q` (string): Search query for products, e.g. 'coffee maker' or 'Nike Air Max'. Required unless shoprs is provided. Supports Google's advanced search operators.
- `light` (boolean): Use the faster google_shopping_light engine — response omits filters/carousel_filters and it misses some products the full engine finds, so an empty light answer is retried once on the full engine (`source` and `note` say so). When false (default) the full google_shopping engine is used.
- `location` (string): Geographic location to originate the search from, e.g. 'Austin, Texas, United States'. Use a canonical Locations API name. Mutually exclusive with uule.
- `uule` (string): Google-encoded location string (the encoded form of a location). Mutually exclusive with location.
- `google_domain` (string): Google domain to use, e.g. 'google.com', 'google.co.uk', 'google.de'. Default google.com.
- `gl` (string): Country code for the search, e.g. 'us', 'uk', 'de'.
- `hl` (string): Language code, e.g. 'en', 'es', 'fr', 'pt-br'.
- `min_price` (integer): Minimum product price filter, in the local currency.
- `max_price` (integer): Maximum product price filter, in the local currency.
- `sort_by` (integer): Sort order: 1 = price low→high, 2 = price high→low. Omit for default relevance ranking.
- `free_shipping` (boolean): Only show products offering free shipping. Default false.
- `on_sale` (boolean): Only show products that are on sale. Default false.
- `small_business` (boolean): Only show products from small businesses. Default false.
- `shoprs` (string): Refinement token from a prior result's filters/carousel_filters, used to apply a filter or refine the search. When set, q is optional.
- `start` (integer): Result offset for pagination (0-based, e.g. 0, 60, 120). Default 0.
- `device` (string): Device to emulate: 'desktop' (default), 'tablet' or 'mobile'. One of: desktop, tablet, mobile.
- `no_cache` (boolean): Force a fresh SerpAPI fetch and bypass this server's result cache. Default false.
- `zero_trace` (boolean): Enterprise-only ZeroTrace mode: don't store search params/metadata on SerpAPI. Default false.

## YouTube MCP

Endpoint: https://mcp.wondel.ai/youtube/mcp
YouTube search: find videos, fetch details and comments, pull full transcripts.
Latency: ~2–8 s via SerpAPI
Docs: https://mcps.wondel.ai/servers/youtube/
Source: YouTube (https://www.youtube.com)

### youtube_search

Search YouTube live via SerpAPI. Returns video_results (videos), plus channels, playlists, movies and related searches. Each video result's id is the YouTube video id — feed it as `v` to youtube_video (details, related videos, comments) and to youtube_transcript. `sp` carries SerpAPI filter and next-page tokens from a prior result for pagination / refined filtering.

Parameters:
- `search_query` (string, required): Search query for YouTube (required). Same syntax as the YouTube search box.
- `gl` (string): Country code for the search, e.g. 'us', 'uk', 'de'.
- `hl` (string): Language code, e.g. 'en', 'es', 'pt-br'.
- `sp` (string): Filter / pagination token from a prior result: carries YouTube search filters and the next-page token.
- `no_cache` (boolean): Force a fresh SerpAPI fetch and bypass this server's result cache. Default false.
- `zero_trace` (boolean): Enterprise-only ZeroTrace mode: don't store search params/metadata on SerpAPI. Default false.

### youtube_video

Fetch a single YouTube video by id via SerpAPI: details, related videos, comments and replies. `v` is the video id from a youtube_search video_results entry. Page related videos / comments / replies with next_page_token from a prior result.

Parameters:
- `v` (string, required): YouTube video id (required), e.g. the id from a youtube_search video_results entry.
- `gl` (string): Country code for the search, e.g. 'us', 'uk', 'de'.
- `hl` (string): Language code, e.g. 'en', 'es', 'pt-br'.
- `next_page_token` (string): Token from a prior result to page through related videos, comments, or replies.
- `no_cache` (boolean): Force a fresh SerpAPI fetch and bypass this server's result cache. Default false.
- `zero_trace` (boolean): Enterprise-only ZeroTrace mode: don't store search params/metadata on SerpAPI. Default false.

### youtube_transcript

Fetch a YouTube video's transcript via SerpAPI. `v` is the video id from a youtube_search result. Pick a track with language_code (default 'en' — use the video's own language), and optionally title and type ('asr' for auto-generated captions). When the requested track doesn't exist the tool falls back once to an available track (same language first, manual before auto-generated) and says so in `note`.

Parameters:
- `v` (string, required): YouTube video id (required) — the id from a youtube_search result.
- `language_code` (string): Transcript language code, e.g. 'en', 'pl'. Default 'en' — pass the video's own language. If that track doesn't exist, an available one is used instead and `note` says which.
- `title` (string): Transcript track title to select when multiple tracks exist.
- `type` (string): Transcript track type: 'asr' for auto-generated captions; omit for manual captions. If that track doesn't exist, an available one is used instead and `note` says which.
- `no_cache` (boolean): Force a fresh SerpAPI fetch and bypass this server's result cache. Default false.
- `zero_trace` (boolean): Enterprise-only ZeroTrace mode: don't store search params/metadata on SerpAPI. Default false.

## Google Search MCP

Endpoint: https://mcp.wondel.ai/google-search/mcp
Fast Google web search: organic results and related questions, no ads.
Latency: ~1–4 s via SerpAPI (google_light engine)
Docs: https://mcps.wondel.ai/servers/google-search/
Source: Google Search (https://www.google.com)

### google_search

Fast Google web search via SerpAPI's google_light engine. Returns organic_results, related_questions and related_searches (lighter and faster than the full Google engine; no ads, inline images or other rich elements). Paginate with start (+10 results per page: 0, 10, 20, …). Localize with location or uule (mutually exclusive), gl/hl for country/language, and lr to restrict result languages.

Parameters:
- `q` (string, required): Search query / keywords (required). Supports standard Google operators (site:, intitle:, quotes, …).
- `location` (string): Geographic location to originate the search from, e.g. 'Austin, Texas, United States'. Mutually exclusive with uule.
- `uule` (string): Google-encoded location string (uule); advanced alternative to location. Mutually exclusive with location.
- `google_domain` (string): Google domain to use, e.g. 'google.com', 'google.co.uk', 'google.de'. Default google.com.
- `gl` (string): Country code for the search, e.g. 'us', 'uk', 'de'.
- `hl` (string): Language code, e.g. 'en', 'es', 'fr'.
- `lr` (string): Restrict results to one or more languages, e.g. 'lang_en' or 'lang_en|lang_fr'.
- `safe` (string): SafeSearch level: 'active' to filter explicit results, 'off' to disable. One of: active, off.
- `nfpr` (integer): Exclude auto-corrected (spelling-fix) results: 1 = exclude (use the exact query), 0 = allow (default).
- `filter` (integer): 'Similar Results' and 'Omitted Results' filter: 1 = on (default), 0 = off (show all).
- `start` (integer): Result offset for pagination (0-based): 0 = page 1, 10 = page 2, 20 = page 3, … (+10 per page).
- `device` (string): Device to emulate for the search: 'desktop' (default), 'tablet' or 'mobile'. One of: desktop, tablet, mobile.
- `no_cache` (boolean): Force a fresh SerpAPI fetch and bypass this server's result cache. Default false.
- `zero_trace` (boolean): Enterprise-only ZeroTrace mode: don't store search params/metadata on SerpAPI. Default false.

## eBay MCP

Endpoint: https://mcp.wondel.ai/ebay/mcp
Search any eBay marketplace and fetch full item details for one listing.
Latency: ~2–8 s via SerpAPI
Docs: https://mcps.wondel.ai/servers/ebay/
Source: eBay (https://www.ebay.com)

### ebay_search

Search eBay listings live via SerpAPI (engine `ebay`). Returns organic_results (each with title, link, condition, price, shipping, seller and — crucially — a `product_id`), plus categories, related_searches and pagination. Provide `_nkw` (a free-text query, what you'd type in eBay's search box) and/or a `category_id` to browse a category. Filter by price (`_udlo`/`_udhi`), condition (`LH_ItemCondition`), buying format (`buying_format`), seller (`_sasl`) and more; sort with `_sop` and paginate with `_pgn`. Pass a result's `product_id` to the `ebay_product` tool for full item details. Prices are in the marketplace currency (set via `ebay_domain`, default ebay.com).

Parameters:
- `_nkw` (string): Search query — anything you'd type in eBay's search box. Required unless category_id is set.
- `category_id` (string): eBay category id to concentrate the search in. Can be used with or instead of _nkw.
- `ebay_domain` (string): eBay marketplace domain, e.g. 'ebay.com' (default), 'ebay.de', 'ebay.co.uk', 'ebay.com.au'.
- `_salic` (string): Filter items by location, as a country code (e.g. '1' for US — see eBay location ids).
- `_pgn` (integer): Page number (1-based). Default 1.
- `_ipg` (integer): Results per page. Allowed values: 25, 50 (default), 100, 200.
- `_sop` (string): Sort order code: '12' = Best Match (default), '1' = ending soonest, '10' = newly listed, '15' = price+shipping lowest first, '16' = price+shipping highest first.
- `_dmd` (string): Result layout: 'Grid' or 'List'. Cosmetic; does not change the items returned.
- `_udlo` (number): Minimum price (in the marketplace currency).
- `_udhi` (number): Maximum price (in the marketplace currency).
- `LH_ItemCondition` (string): Item condition id(s), pipe-separated for multiple ('1000|3000'): 1000 New, 1500 Open box, 2500 Seller refurbished, 3000 Used, 7000 For parts/not working, 10 Not specified.
- `buying_format` (string): Buying format filter: 'Auction', 'BIN' (Buy It Now) or 'BO' (Best Offer).
- `show_only` (string): Extra filters, comma-separated: Sold, Complete (sold & completed listings), FS (free shipping), FR (free returns), RPA (returns accepted), Lots, Charity, Savings, SaleItems, AS, AV, LPickup.
- `LH_PrefLoc` (string): Preferred item location: 'Domestic', 'Regional' or 'Worldwide' (mapped internally to SerpAPI's numeric LH_PrefLoc codes — the words themselves are rejected by the upstream API).
- `_stpos` (string): Buyer ZIP/postal code, used for location- and shipping-based filtering.
- `_sasl` (string): Seller username(s) to filter by, comma-separated.
- `_saslop` (integer): How to apply _sasl: 1 = only these sellers (default), 2 = exclude these sellers.
- `_blrs` (string): Set to 'spell_auto_correct' to exclude results from an auto-corrected spelling of the query.
- `no_cache` (boolean): Force a fresh SerpAPI fetch and bypass this server's result cache. Default false.
- `zero_trace` (boolean): Enterprise-only ZeroTrace mode: don't store search params/metadata on SerpAPI. Default false.

### ebay_product

Get full details for a single eBay item via SerpAPI (engine `ebay_product`). Pass `product_id` — the eBay item id taken from an `ebay_search` result's `product_id` field (also the number in an /itm/<id> URL). Returns product_results (title, pricing/buying options, condition, quantity, shipping, specifications, variations, media, returns), seller_results and related_products. Use `ebay_domain` to match the marketplace the item was found on.

Parameters:
- `product_id` (string, required): eBay item id — the `product_id` from an ebay_search result (or the number in an /itm/<id> URL).
- `ebay_domain` (string): eBay marketplace domain the item is on, e.g. 'ebay.com' (default), 'ebay.de', 'ebay.co.uk'.
- `locale` (string): Origin location the request should appear to come from.
- `lang` (string): Language code, e.g. 'en-US' (default). Only used for the US eBay domain when locale is set.
- `shipping_country` (string): Destination country code used to calculate shipping data.
- `no_cache` (boolean): Force a fresh SerpAPI fetch and bypass this server's result cache. Default false.
- `zero_trace` (boolean): Enterprise-only ZeroTrace mode: don't store search params/metadata on SerpAPI. Default false.

## NBP MCP

Endpoint: https://mcp.wondel.ai/nbp/mcp
Official Polish central bank (NBP) exchange rates, currency conversion and gold prices.
Latency: <1 s, free public api.nbp.pl (no key)
Docs: https://mcps.wondel.ai/servers/nbp/
Source: Narodowy Bank Polski (https://api.nbp.pl)

### nbp_exchange_rates

Get a full NBP (Polish central bank) exchange-rate table against PLN — the latest published table by default, or the table in force on a historical date. NBP publishes only on Polish business days — on weekends/holidays the request falls back to the most recent preceding publication; effectiveDate in the response shows the date actually used. Rates data starts 2002-01-02.

Parameters:
- `table` (string): NBP table: 'a' (default) = official mid rates of ~35 major currencies, published every business day; 'b' = mid rates of ~115 less-traded currencies, published Wednesdays; 'c' = bid/ask (buy/sell) rates of major currencies, published every business day. One of: a, b, c.
- `date` (string): Optional historical date (YYYY-MM-DD). Omit for the latest table.
- `no_cache` (boolean): Force a fresh NBP fetch and bypass this server's result cache. Default false.

### nbp_exchange_rate

Get the official NBP rate for one currency against PLN (Polish złoty) — the latest rate by default, or the rate in force on a historical date. Tables 'a'/'b' return the mid rate; table 'c' returns bid/ask. NBP publishes only on Polish business days — on weekends/holidays the request falls back to the most recent preceding publication; effectiveDate in the response shows the date actually used. Use nbp_rate_series for a multi-day history.

Parameters:
- `code` (string, required): Three-letter ISO 4217 currency code (e.g. USD, EUR, CHF). Case-insensitive.
- `table` (string): NBP table: 'a' (default) = official mid rates of ~35 major currencies, published every business day; 'b' = mid rates of ~115 less-traded currencies, published Wednesdays; 'c' = bid/ask (buy/sell) rates of major currencies, published every business day. One of: a, b, c.
- `date` (string): Optional historical date (YYYY-MM-DD). Omit for the latest rate.
- `no_cache` (boolean): Force a fresh NBP fetch and bypass this server's result cache. Default false.

### nbp_rate_series

Get a historical time series of NBP rates for one currency against PLN: either the last N published quotes (last_n, default 30, max 255) or an explicit start_date/end_date window (max 93 days per query — NBP's hard limit; chain calls for longer spans). Quotes exist only for publication days: business days for tables 'a'/'c', Wednesdays for 'b'. Data starts 2002-01-02.

Parameters:
- `code` (string, required): Three-letter ISO 4217 currency code (e.g. USD, EUR, CHF). Case-insensitive.
- `table` (string): NBP table: 'a' (default) = official mid rates of ~35 major currencies, published every business day; 'b' = mid rates of ~115 less-traded currencies, published Wednesdays; 'c' = bid/ask (buy/sell) rates of major currencies, published every business day. One of: a, b, c.
- `last_n` (integer): Return the last N published quotes (1-255). Default 30. Mutually exclusive with start_date/end_date.
- `start_date` (string): Window start (YYYY-MM-DD, inclusive). Requires end_date.
- `end_date` (string): Window end (YYYY-MM-DD, inclusive). Requires start_date; span ≤ 93 days.
- `no_cache` (boolean): Force a fresh NBP fetch and bypass this server's result cache. Default false.

### nbp_convert

Convert an amount between two currencies using official NBP mid rates, cross-rated through PLN. Supports PLN and every currency NBP quotes: table A is used first and table B (exotic currencies, published Wednesdays) is consulted automatically for codes A doesn't carry — each side of the response shows the rate, table and effectiveDate used. Latest rates by default, or historical with date. NBP publishes only on Polish business days — on weekends/holidays the request falls back to the most recent preceding publication; effectiveDate in the response shows the date actually used.

Parameters:
- `from` (string, required): Source currency code (e.g. USD, PLN). Case-insensitive.
- `to` (string, required): Target currency code (e.g. EUR, PLN). Case-insensitive.
- `amount` (number, required): Amount in the source currency to convert.
- `date` (string): Optional historical date (YYYY-MM-DD). Omit for the latest rates.
- `no_cache` (boolean): Force a fresh NBP fetch and bypass this server's result cache. Default false.

### nbp_gold_price

Get the official NBP gold price — PLN per 1 gram of 1000-fineness gold. Latest price by default; or one historical date; or the last N quotes (last_n, max 255); or a start_date/end_date range (max 93 days per query). Published every business day. NBP publishes only on Polish business days — on weekends/holidays the request falls back to the most recent preceding publication; effectiveDate in the response shows the date actually used. Gold data starts 2013-01-02.

Parameters:
- `date` (string): One historical date (YYYY-MM-DD). Mutually exclusive with last_n and the range.
- `last_n` (integer): Return the last N published prices (1-255). Mutually exclusive with date and the range.
- `start_date` (string): Range start (YYYY-MM-DD, inclusive). Requires end_date.
- `end_date` (string): Range end (YYYY-MM-DD, inclusive). Requires start_date; span ≤ 93 days.
- `no_cache` (boolean): Force a fresh NBP fetch and bypass this server's result cache. Default false.

## Wizzair MCP

Endpoint: https://mcp.wondel.ai/wizzair/mcp
Wizzair fares, routes, timetables and flight details across its network.
Latency: ~2–10 s, direct fetch to be.wizzair.com; wizzair_search_flights is experimental (Kasada-protected endpoint)
Docs: https://mcps.wondel.ai/servers/wizzair/
Source: Wizz Air (https://www.wizzair.com)

### wizzair_search_fares

Cheapest Wizzair fare per day around a date (fare chart, ±day_interval days — up to a 19-day window). Returns one price per day in the route's local currency, plus return-leg days when return_date is set, and a wizzair.com fare-finder link. Data comes live from Wizzair's private booking API (unofficial — may briefly fail if Wizzair rotates or throttles it). Use wizzair_search_timetable for departure times, wizzair_search_flight_dates for operating days.

Parameters:
- `departure_station` (string, required): Departure airport IATA code (3-letter, e.g. WAW).
- `arrival_station` (string, required): Arrival airport IATA code (3-letter, e.g. BCN).
- `date` (string, required): Center date of the window, YYYY-MM-DD.
- `return_date` (string): Return-leg center date, YYYY-MM-DD. Omit for one-way.
- `day_interval` (integer): Days around the date to include (±N). Default 9; Wizzair's minimum is 3 — lower values are bumped.
- `adults` (integer): Number of adults. Default 1.
- `children` (integer): Number of children. Default 0.
- `wdc` (boolean): Price with the Wizz Discount Club (WDC) membership discount. Default false.
- `no_cache` (boolean): Force a fresh Wizzair fetch and bypass this server's result cache. Default false.

### wizzair_search_routes

Wizzair's route map: pass a station IATA code to list its direct connections (city, country, is_new), or omit it to list every Wizzair city with its destination count. Cached for 6 hours. Data comes live from Wizzair's private booking API (unofficial — may briefly fail if Wizzair rotates or throttles it). Result shape: { source, fetchedAt, query, mode, count, route_map_url, ... }. With station: mode='single_station', station, station_name, country, connections: [{ iata, city, country, is_new }]. Without: mode='all_cities', cities: [{ iata, city, country, country_code, destinations }]. The list key is `connections` (or `cities`), never `routes`.

Parameters:
- `station` (string): Station IATA code to list connections from (e.g. WAW). Omit to list all Wizzair cities.
- `no_cache` (boolean): Force a fresh Wizzair fetch and bypass this server's result cache. Default false.

### wizzair_search_flight_dates

Dates with available Wizzair flights on a route within a from/to window — the fastest way to see which days a route operates before asking for prices. Data comes live from Wizzair's private booking API (unofficial — may briefly fail if Wizzair rotates or throttles it).

Parameters:
- `departure_station` (string, required): Departure airport IATA code (3-letter, e.g. WAW).
- `arrival_station` (string, required): Arrival airport IATA code (3-letter, e.g. BCN).
- `from_date` (string, required): Window start, YYYY-MM-DD.
- `to_date` (string, required): Window end, YYYY-MM-DD.
- `no_cache` (boolean): Force a fresh Wizzair fetch and bypass this server's result cache. Default false.

### wizzair_search_timetable

Wizzair daily prices AND all departure times on a route in a from/to window (outbound leg): per day you get the price in the route's local currency plus each departure datetime. Data comes live from Wizzair's private booking API (unofficial — may briefly fail if Wizzair rotates or throttles it).

Parameters:
- `departure_station` (string, required): Departure airport IATA code (3-letter, e.g. WAW).
- `arrival_station` (string, required): Arrival airport IATA code (3-letter, e.g. BCN).
- `from_date` (string, required): Window start, YYYY-MM-DD.
- `to_date` (string, required): Window end, YYYY-MM-DD.
- `adults` (integer): Number of adults. Default 1.
- `children` (integer): Number of children (2-14). Default 0.
- `infants` (integer): Number of infants (under 2). Default 0.
- `wdc` (boolean): Price with the Wizz Discount Club (WDC) membership discount. Default false.
- `no_cache` (boolean): Force a fresh Wizzair fetch and bypass this server's result cache. Default false.

### wizzair_search_flights

EXPERIMENTAL: detailed Wizzair flights for exact dates with fare bundles (Basic/WIZZ Go/WIZZ Plus — base, discounted and WDC price per bundle, flight numbers, exact times). This endpoint sits behind Kasada bot protection and may return a rate-limited error — fall back to wizzair_search_timetable or wizzair_search_fares when it does. Data comes live from Wizzair's private booking API (unofficial — may briefly fail if Wizzair rotates or throttles it).

Parameters:
- `departure_station` (string, required): Departure airport IATA code (3-letter, e.g. WAW).
- `arrival_station` (string, required): Arrival airport IATA code (3-letter, e.g. BCN).
- `departure_date` (string, required): Departure date, YYYY-MM-DD.
- `return_date` (string): Return date, YYYY-MM-DD. Omit for one-way.
- `adults` (integer): Number of adults. Default 1.
- `children` (integer): Number of children. Default 0.
- `infants` (integer): Number of infants. Default 0.
- `wdc` (boolean): Price with the WDC membership discount. Default TRUE for this tool.
- `no_cache` (boolean): Force a fresh Wizzair fetch and bypass this server's result cache. Default false.

## Czartery MCP

Endpoint: https://mcp.wondel.ai/czartery/mcp
Polish charter flight search across Rainbow, Itaka and TUI operators, prices in PLN.
Latency: ~2–10 s, direct fetch to each operator's JSON/RSC endpoint
Docs: https://mcps.wondel.ai/servers/czartery/
Source: Rainbow Tours (https://biletyczarterowe.r.pl), Itaka (https://www.itaka.pl), TUI Poland (https://www.tui.pl)

### rainbow_search_charters

Charter flight destinations sold by Rainbow Tours (biletyczarterowe.r.pl) matching optional destination/origin/date filters: per destination you get the country, region, nearest departure date, baggage allowance and the lowest per-person price. Prices are charter seat prices in PLN. Use rainbow_search_outbound for day-by-day flights to one destination. Result shape: { source, fetchedAt, query, search_url, count, flights: [...], price_range: { min, max } } — the list key is `flights`, but each entry is a DESTINATION, not a single flight: { destination, destination_iata, country, region, departure_date, price_per_person, currency, baggage_kg }.

Parameters:
- `destinations` (array): Destination IATA codes to filter by, e.g. ['AYT','HRG']. Omit for all.
- `origins` (array): Polish origin IATA codes to filter by, e.g. ['WAW','KTW']. Omit for all.
- `departure_from` (string): Earliest departure date, YYYY-MM-DD.
- `departure_to` (string): Latest departure date, YYYY-MM-DD.
- `adults` (integer): Number of adults. Default 2.
- `one_way` (boolean): Search one-way charters instead of returns. Default false.
- `no_cache` (boolean): Force a fresh fetch and bypass this server's result cache. Default false.

### rainbow_search_outbound

Day-by-day outbound charter flights to ONE Rainbow destination in a date window: per day the cheapest price and every flight with origin, departure time, airline, flight number, baggage and per-person/total price. Prices are charter seat prices in PLN. Get destination codes from rainbow_search_charters. Result shape: { source, fetchedAt, query, search_url, destination, period, days_with_flights, days: [...] } — the list key is `days`, one entry per calendar day: { date, cheapest_price, flights: [{ origin, destination, departure_time, price_per_person, total_price, currency, airline_code, flight_number, cabin_baggage_kg, checked_baggage_kg, meals_included }] }. A day with no flights is simply absent.

Parameters:
- `destination` (string, required): Destination IATA code, e.g. AYT.
- `date_from` (string, required): Window start, YYYY-MM-DD.
- `date_to` (string, required): Window end, YYYY-MM-DD.
- `origins` (array): Polish origin IATA codes to filter by. Omit for all.
- `adults` (integer): Number of adults. Default 2.
- `no_cache` (boolean): Force a fresh fetch and bypass this server's result cache. Default false.

### itaka_search_charters

Charter flight itineraries from Itaka.pl between a Polish origin and a charter destination: each itinerary carries full legs (airports, dates, times, carrier, stops), per-person and total price, and a direct booking URL. Prices are charter seat prices in PLN. Only supports Itaka's fixed airport list — the error message lists valid codes when one is unsupported. Result shape: { source, fetchedAt, query, search_url, route, total_pages, current_page, total_rates, count, itineraries: [...] } — the list key is `itineraries`. Each: { trip_type, price_total, price_per_person, currency, booking_url, outbound, return_flight }, where outbound/return_flight are { departure: { city, airport_code, date, time, carrier, flight_number }, arrival: { city, airport_code, date, time }, duration_minutes, stops } and `return_flight` is null on a one-way.

Parameters:
- `origin` (string, required): Polish origin IATA code (WAW, KRK, GDN, KTW, WRO, POZ, RZE, SZZ, BZG, LCJ, LUZ, RDO, SZY, IEG).
- `destination` (string, required): Destination IATA code from Itaka's charter network, e.g. AYT, HER, FNC.
- `flight_type` (string): Trip type. Default returnTicket. One of: returnTicket, oneWayTicket.
- `adults` (integer): Number of adults. Default 2.
- `page` (integer): 1-indexed result page. Default 1.
- `sort_by` (string): Result ordering. Default Itaka's own. One of: priceAsc, priceDesc, dateFromAsc, dateFromDesc.
- `no_cache` (boolean): Force a fresh fetch and bypass this server's result cache. Default false.

### tui_search_charters

Charter destinations sold on TUI.pl for a stay-length window, with per-person and total prices: filter by origin/destination airports and trip duration in days. Prices are charter seat prices in PLN. Result shape: { source, fetchedAt, query, search_url, passengers, duration, count, destinations: [...] } — the list key is `destinations`. Each: { destination_name, airport_code, country, per_person_price, total_price, currency }. There are no per-flight times here; TUI only publishes a destination price.

Parameters:
- `adults` (integer): Number of adults. Default 2.
- `departure_airports` (array): Origin IATA codes to filter by, e.g. ['WAW']. Omit for all.
- `destination_airports` (array): Destination IATA codes to filter by, e.g. ['AYT']. Omit for all.
- `duration_from` (integer): Minimum stay length in days. Default 6.
- `duration_to` (integer): Maximum stay length in days. Default 8.
- `no_cache` (boolean): Force a fresh fetch and bypass this server's result cache. Default false.

## Skyscanner MCP

Endpoint: https://mcp.wondel.ai/skyscanner/mcp
Live Skyscanner fares in PLN: best-ranked one-way or round-trip itineraries, cheapest/fastest price, booking links.
Latency: ~20–40 s, live render of the skyscanner.pl results page via Firecrawl; 5 min cache
Docs: https://mcps.wondel.ai/servers/skyscanner/
Source: Skyscanner (https://www.skyscanner.pl)

### skyscanner_search_flights

Search live Skyscanner (skyscanner.pl) fares for a one-way or round trip: the itineraries Skyscanner ranks best — total price in PLN, airlines, per-leg local times, duration, stops, self-transfer flag and a booking link — plus the cheapest and fastest fare across the whole search. The results page is rendered live through a paid unblocker, so a call takes ~20–40 s; finished searches are cached for 5 minutes. `search_complete: false` means Skyscanner was still collecting prices when the page was captured (calling again usually returns the finished search). For stop/time/airline filters or other currencies use google_flights_search. Result shape: { source, fetched_at, query, trip_type, search_url, currency, search_complete, providers_checked, providers_total, total_results, summary: { best, cheapest, fastest } (each { price_per_person, duration_minutes }), count, itineraries: [...], note } — the list key is `itineraries`, never `flights` or `results`. Each itinerary: { price, price_per_person, currency, airlines, legs: [...], self_transfer, offers_count, url }; each leg: { origin, origin_name, destination, destination_name, departure, arrival, duration_minutes, stops, stopovers, airlines, change_airport }. `price` is a number — the total for all passengers and both directions, taxes included; `price_per_person` is the fare per passenger; `departure`/`arrival` are local times 'YYYY-MM-DDTHH:MM'; a round trip has two legs (outbound, then return) under one price.

Parameters:
- `origin` (string, required): Origin: IATA airport code (e.g. WAW) or Skyscanner city code (e.g. LOND = all London airports).
- `destination` (string, required): Destination: IATA airport code (e.g. LHR, BCN) or Skyscanner city code (e.g. LOND).
- `departure_date` (string, required): Departure date, YYYY-MM-DD (today or later).
- `return_date` (string): Return date, YYYY-MM-DD. Omit for a one-way search.
- `adults` (integer): Number of adults, 1–8. Default 1.
- `cabin_class` (string): Cabin class. Default economy. One of: economy, premium_economy, business, first.
- `no_cache` (boolean): Bypass the 5-minute result cache and render a fresh search.

## Booking MCP

Endpoint: https://mcp.wondel.ai/booking/mcp
Experimental Booking.com hotel search: nightly price, rating, stars and booking link.
Latency: ~3–20 s, HTML scrape; AWS WAF often forces the unblocker fallback
Docs: https://mcps.wondel.ai/servers/booking/
Source: Booking.com (https://www.booking.com)

### booking_search_hotels

EXPERIMENTAL: hotels on Booking.com for a location and stay window, scraped from the search-results page: name, nightly price, review score + count, star class, image and a direct booking link per property. Booking sits behind AWS WAF, so the call may return a blocked error — google_hotels_search is the reliable alternative (and covers Booking's prices among OTAs). Result shape: { source, fetchedAt, experimental, query, search_url, location, checkin, checkout, currency, count, hotels: [...] } — the list key is `hotels`. Each hotel: { name, price_per_night, currency, rating, reviews, hotel_class, booking_url, thumbnail } (fields are null when Booking omits them).

Parameters:
- `location` (string, required): Free-text location, e.g. 'Warsaw' or 'Zakopane, Poland'.
- `checkin` (string, required): Check-in date, YYYY-MM-DD.
- `checkout` (string, required): Check-out date, YYYY-MM-DD.
- `adults` (integer): Number of adults. Default 2.
- `rooms` (integer): Number of rooms. Default 1.
- `currency` (string): ISO currency for prices (e.g. 'PLN', 'EUR'). Omit for Booking's default for the region.
- `limit` (integer): Max hotels to return (default 25).
- `no_cache` (boolean): Force a fresh Booking.com fetch and bypass this server's result cache. Default false.

## FlightAware MCP

Endpoint: https://mcp.wondel.ai/flightaware/mcp
Live flight status and scheduled-route search via the official FlightAware AeroAPI.
Latency: ~1–3 s, official AeroAPI; needs FLIGHTAWARE_API_KEY, bills usage per call
Docs: https://mcps.wondel.ai/servers/flightaware/
Source: FlightAware (AeroAPI) (https://www.flightaware.com)

### flightaware_flight_status

Live or planned status of a flight via the official FlightAware AeroAPI: times (scheduled/estimated/actual), delays, gates/terminals, aircraft, progress, cancelled/diverted flags, plus flightaware.com tracking links. Operational data, not prices. Requires the FLIGHTAWARE_API_KEY secret; each call bills AeroAPI usage.

Parameters:
- `ident` (string, required): Flight ident: IATA number (LO281), ICAO number (BAW123), or tail/registration (SP-LVD).
- `max_pages` (integer): AeroAPI pagination cap — how many result pages to fetch (each page bills separately). Default 1.
- `no_cache` (boolean): Force a fresh AeroAPI fetch and bypass this server's result cache. Default false.

### flightaware_search_scheduled

Scheduled (future) flights between two airports in a date window via the official FlightAware AeroAPI /schedules endpoint: ident, operator, scheduled out/in times and aircraft type per flight. Use it to see what actually flies a route on given days; it returns no prices. Requires the FLIGHTAWARE_API_KEY secret; each call bills AeroAPI usage.

Parameters:
- `origin` (string, required): Origin airport IATA or ICAO code (e.g. WAW or EPWA).
- `destination` (string, required): Destination airport IATA or ICAO code.
- `date_start` (string, required): Window start date, YYYY-MM-DD.
- `date_end` (string, required): Window end date, YYYY-MM-DD (exclusive per AeroAPI semantics).
- `max_pages` (integer): AeroAPI pagination cap — how many result pages to fetch (each page bills separately). Default 1.
- `no_cache` (boolean): Force a fresh AeroAPI fetch and bypass this server's result cache. Default false.

## Kayak MCP

Endpoint: https://mcp.wondel.ai/kayak/mcp
Builds a Kayak.com flight-search deep link for a route and dates — URL only, no prices.
Latency: instant — pure URL builder, no HTTP call at all
Docs: https://mcps.wondel.ai/servers/kayak/
Source: KAYAK (https://www.kayak.com)

### kayak_search_flights

Build a Kayak.com flight-search deep link for a route and dates. Returns the URL only — no prices: Kayak renders fares client-side behind bot protection, so a server-side fetch can't read them. Open deep_link in a browser for live results, or use google_flights_search for parsed fares. Result shape: { source, deep_link, search_url, trip_type, origin, destination, departure_date, return_date, cabin_class, adults, note } — a single object, never a list: there are no fares, flights or offers to read. `deep_link` (identical to `search_url`) is the only useful output; `return_date` is null for a one-way.

Parameters:
- `origin` (string, required): Origin airport IATA code (3-letter, e.g. WAW).
- `destination` (string, required): Destination airport IATA code (3-letter, e.g. JFK).
- `departure_date` (string, required): Departure date, YYYY-MM-DD.
- `return_date` (string): Return date, YYYY-MM-DD. Omit for one-way.
- `adults` (integer): Number of adults. Default 1.
- `cabin_class` (string): Cabin class. Default economy. One of: economy, premium_economy, business, first.

## Nieruchomosci Online MCP

Endpoint: https://mcp.wondel.ai/nieruchomosci-online/mcp
Polish property listings on nieruchomosci-online.pl: flats, houses, plots, premises for sale or rent.
Latency: ~1–3 s, direct HTML fetch (unblocker fallback only on a blocked page)
Docs: https://mcps.wondel.ai/servers/nieruchomosci-online/
Source: Nieruchomosci-Online.pl (https://www.nieruchomosci-online.pl)

### nieruchomosci_online_search

Search property listings on nieruchomosci-online.pl, one of Poland's largest real-estate portals: flats, houses, plots, commercial premises and rooms, for sale or for rent, filtered by city/district or voivodeship, price, area, rooms and private-owner-only. Returns one results page (~40 listings) with each listing's price, price per m², area, rooms, floor, location, seller type and link; pass a listing `id` to nieruchomosci_online_offer for the full details. Fetched live from nieruchomosci-online.pl (typically 1–3 s via direct fetch; up to ~20 s when it falls back to an unblocker). Result shape: { source, fetchedAt, query, search_url, heading, resolved_location, total_count, page, total_pages, count, listings: [...], note? } — the list key is `listings`; `total_count` counts matches across all pages (use `page` for more). Each listing: { id, url, title, kind, market, price, price_per_m2, currency, area_m2, rooms, floor, location, street, city, region, seller_type, image, description }. Prices are numbers in PLN (for rent, `price` is the monthly rent) and area is in m²; fields are null when the page omits them. `kind` is 'new_development' for a developer's unit in a new project (primary market), else 'listing'; `seller_type` is agency | private | developer | company. An empty match answers count: 0 with a `note` saying why and what to change — that is a successful result, not an error.

Parameters:
- `type` (string, required): Property type: 'flat' = mieszkanie, 'house' = dom, 'plot' = działka (land), 'commercial' = lokal użytkowy (office, shop, premises), 'commercial_building' = budynek użytkowy, 'room' = pokój (a room to rent). One of: flat, house, plot, commercial, commercial_building, room.
- `transaction` (string, required): 'sale' = na sprzedaż (buying), 'rent' = na wynajem (renting; prices are monthly). One of: sale, rent.
- `location` (string): City in Polish spelling, optionally followed by a district: 'Kraków', 'Warszawa Mokotów', 'Gdańsk Wrzeszcz'. English names ('Warsaw') are not recognised. Omit to search all of Poland, or pass region instead.
- `region` (string): A whole voivodeship instead of a city, e.g. 'malopolskie', 'mazowieckie'. Not combinable with location. One of: dolnoslaskie, kujawsko-pomorskie, lubelskie, lubuskie, lodzkie, malopolskie, mazowieckie, opolskie, podkarpackie, podlaskie, pomorskie, slaskie, swietokrzyskie, warminsko-mazurskie, wielkopolskie, zachodniopomorskie.
- `price_min` (number): Minimum total price in PLN (monthly rent when transaction is 'rent').
- `price_max` (number): Maximum total price in PLN (monthly rent when transaction is 'rent').
- `area_min` (number): Minimum area in m² (the plot's area for type 'plot').
- `area_max` (number): Maximum area in m² (the plot's area for type 'plot').
- `rooms_min` (integer): Minimum number of rooms — types 'flat' and 'house' only.
- `rooms_max` (integer): Maximum number of rooms — types 'flat' and 'house' only (use min = max for exactly N).
- `private_only` (boolean): Only listings posted by private owners (bez pośredników) — no agencies or developers. Default false.
- `page` (integer): Results page, 1-based (~40 listings per page). Default 1.
- `no_cache` (boolean): Force a fresh fetch and bypass this server's result cache (5 min). Default false.

### nieruchomosci_online_offer

Full details of one nieruchomosci-online.pl listing: price and price per m² (PLN), area, rooms, floor, year built, address with district and coordinates, seller type and name (agency, developer or private), the listing's detail table as shown on the page (Polish labels and values: rent and extra charges, deposit, building, heating, parking, source…), amenities, the full description and photo URLs. Get the id from nieruchomosci_online_search. Fetched live from nieruchomosci-online.pl (typically 1–3 s via direct fetch; up to ~20 s when it falls back to an unblocker). Result: { source, fetchedAt, listing: { id, url, title, property_type, transaction, kind, market, price, price_per_m2, currency, area_m2, rooms, floor, year_built, address, geo, seller_type, seller_name, agent_name, date_posted, updated, details, amenities, description, photos } }.

Parameters:
- `id` (string, required): Listing id (digits, e.g. '26982481') or the listing's full URL, as returned by nieruchomosci_online_search.
- `no_cache` (boolean): Force a fresh fetch and bypass this server's result cache (5 min). Default false.

## Noclegi MCP

Endpoint: https://mcp.wondel.ai/noclegi/mcp
Places to stay in Poland on noclegi.pl: hotels, guest houses, apartments, cottages, with total prices for your dates.
Latency: ~1–2 s, direct HTML fetch + the site's place autocomplete (unblocker fallback only on a blocked page)
Docs: https://mcps.wondel.ai/servers/noclegi/
Source: Noclegi.pl (https://noclegi.pl)

### noclegi_search

Search places to stay in a Polish town or region on noclegi.pl — hotels, guest houses, pensions, apartments, cottages, private rooms, agritourism — with the price for the whole stay, board, guest rating, location and link. Filter by property type, board, minimum rating, free cancellation and total price; sort by price, rating or discount. One results page is up to 50 offers; pass a listing's `slug` to noclegi_object for rooms, rate plans, amenities and the description. Fetched live from noclegi.pl (typically ~1 s via direct fetch; up to ~20 s when it falls back to an unblocker). WITH checkin + checkout, each `price` is the total for the whole stay for the given guests in PLN, incl. taxes and fees (e.g. price_for '2 osoby, 2 noce'); sold-out offers stay listed with price null and available false. WITHOUT dates, `price` is only the site's indicative price for 1 night (price_for '2 osoby, 1 noc'), many offers have none, and the result carries a `note` saying so — pass dates to quote a stay. Result shape: { source, fetchedAt, query, search_url, place: { name, slug, kind, area }, heading, stay: { checkin, checkout, nights } | null, guests: { adults, children_ages }, total_count, page, total_pages, count, listings: [...], note? } — the list key is `listings`; `total_count` counts offers across all pages (use `page` for more). Each listing: { id, slug, url, name, type, stars, city, price, price_before_discount, discount_percent, currency, price_for, board, available, free_cancellation, rating, rating_count, rating_label, lat, lng, image, amenities, labels }. `board` is room_only | breakfast | half_board | full_board | …; `rating` is 0–10; `free_cancellation` is the site's deadline text (Polish) or null; `url` opens the property with the same stay. When a place has few offers the site widens to a radius (the note says so; check `city`). An empty match answers count: 0 with a `note` saying why and what to change — that is a successful result, not an error.

Parameters:
- `place` (string, required): Town or region in Poland, Polish name preferred: 'Zakopane', 'Szklarska Poręba', 'Białka Tatrzańska', 'Mazury', 'Tatry', 'Polskie morze', 'Bieszczady'. Resolved through noclegi.pl's own place search (diacritics optional; a few English names such as 'Warsaw' or 'Baltic coast' are mapped). A https://noclegi.pl/<place> link also works.
- `checkin` (string): Arrival date, YYYY-MM-DD (from today to about a year ahead). Pass together with checkout; omit both for undated results.
- `checkout` (string): Departure date, YYYY-MM-DD, after checkin — at most 30 nights (the site drops longer stays).
- `adults` (integer): Adults. Default 2.
- `children_ages` (array): Each child's age in years (0–17), e.g. [4, 9] for two children — prices depend on ages. Default none.
- `types` (array): Only these property types (any of them): hotel, apartment, guest_house (dom gościnny), pension (pensjonat), villa (willa), private_room (kwatera prywatna), wooden_cottage (domek drewniany), year_round_cottage (domek całoroczny), resort (ośrodek wypoczynkowy), agritourism, inn (zajazd), hostel, student_house, sanatorium.
- `board` (string): Only offers with this board: room_only, breakfast, half_board, full_board, soft_all_inclusive, all_inclusive. One of: room_only, breakfast, half_board, full_board, soft_all_inclusive, all_inclusive.
- `min_rating` (number): Only guest ratings of at least 8, 9 or 9.5 (0–10 scale).
- `free_cancellation` (boolean): Only offers that can be cancelled free of charge.
- `price_min` (integer): Minimum total price for the whole stay, whole PLN (needs checkin/checkout).
- `price_max` (integer): Maximum total price for the whole stay, whole PLN (needs checkin/checkout).
- `sort` (string): Order: recommended (default — the site's own ranking, which may depend on commission), rating, price_asc / price_desc (by price per person per night), discount. One of: recommended, rating, price_asc, price_desc, discount.
- `page` (integer): Results page, 1-based (up to 50 offers per page). Default 1.
- `no_cache` (boolean): Force a fresh fetch and bypass this server's result cache (5 min). Default false.

### noclegi_object

Full details of one place to stay on noclegi.pl: description, address and coordinates, guest rating and recent reviews, check-in/check-out times, amenities, photos, and every room type with its size, beds, amenities and — for given dates and guests — its rate plans (price for the stay, board, cancellation terms, prepayment). With checkin/checkout it also returns the total price of the cheapest room combination for the guests and the booking link; without dates, `price_from` is the site's best 1-night price in the next ~90 days and the night it applies to. When the dates cannot be booked (sold out, minimum stay) `price` is null and the note carries the site's reason. noclegi.pl does not publish the property's own phone or email — bookings go through the site. Fetched live from noclegi.pl (typically ~1 s via direct fetch; up to ~20 s when it falls back to an unblocker). Result: { source, fetchedAt, query, page_url, object: { id, slug, url, name, type, stars, description, address, geo, rating, rating_count, checkin_time, checkout_time, breadcrumbs, amenities, photos, reviews, stay, price, price_before_discount, discount_percent, currency, price_for, prepayment, selected_rooms, price_from, availability_note, booking_url, rooms: [{ id, name, available_rooms, max_guests, area_m2, beds, amenities, rates: [{ price, price_before_discount, discount_percent, board, price_for, cancellation, prepayment, bookable }] }] }, note? }. Prices in PLN incl. taxes and fees.

Parameters:
- `object` (string, required): The property: its `slug` from noclegi_search (e.g. 'apartamenty-apartart-zakopane'), its https://noclegi.pl/<slug> link, or its name (looked up through the site's search).
- `checkin` (string): Arrival date, YYYY-MM-DD (from today to about a year ahead). Pass together with checkout; omit both for undated results.
- `checkout` (string): Departure date, YYYY-MM-DD, after checkin — at most 30 nights (the site drops longer stays).
- `adults` (integer): Adults. Default 2.
- `children_ages` (array): Each child's age in years (0–17), e.g. [4, 9] for two children — prices depend on ages. Default none.
- `no_cache` (boolean): Force a fresh fetch and bypass this server's result cache (5 min). Default false.

## AlohaCamp MCP

Endpoint: https://mcp.wondel.ai/alohacamp/mcp
Outdoor stays on AlohaCamp.com: cabins, glamping, tiny houses and camping pitches in Poland, with dated prices in PLN.
Latency: ~1–2 s, direct fetch of the site's Next.js JSON routes and API (unblocker fallback only when blocked)
Docs: https://mcps.wondel.ai/servers/alohacamp/
Source: AlohaCamp (https://alohacamp.com)

### alohacamp_search

Search alohacamp.com, the Polish marketplace for stays in nature: cabins and houses (domki), tiny houses, treehouses, houseboats, yurts, glamping tents, agritourism, and camping pitches (pola namiotowe, caravan pitches), mostly in Poland. Filter by place (a region like Mazury/Bieszczady/Kaszuby, a city, a country) or voivodeship, check-in/check-out dates and party (with dates, only places free for that party are returned, priced for those nights), property type, amenities, surroundings, nightly price and free cancellation. Returns one page of 30 in AlohaCamp's recommended order; pass a property `slug` to alohacamp_property for details and exact per-unit prices. Fetched live from alohacamp.com (typically 1–2 s via direct fetch; a few seconds more right after AlohaCamp deploys, or when it falls back to an unblocker). Result shape: { source, fetchedAt, query, search_url, resolved_location, total_count, page, total_pages, count, nights, properties: [...], note? } — the list key is `properties`; `total_count` counts matches across all pages (use `page` for more). Each property: { id, slug, name, url, city, region, country, lat, lng, property_types, units, max_guests, units_for_party, price_per_night, club_price_per_night, total_price_estimate, currency, rating, review_count, image, photos_count, guests_choice, is_new, only_on_alohacamp, free_cancellation, meals_available, meals_included, extra_fees }. Prices are numbers in PLN: `price_per_night` is the lowest nightly price for the whole party (with dates, the average over those nights; `units_for_party` > 1 means it covers several units), `total_price_estimate` = price_per_night × nights (null without dates; fees in `extra_fees` are paid on top), `club_price_per_night` is a lower members-only price when there is one. `rating` is 0–5 (null without reviews). An empty match answers count: 0 with a `note` saying why and what to change — that is a successful result, not an error.

Parameters:
- `location` (string): Where, resolved by AlohaCamp's own place search: a region ('Mazury', 'Bieszczady', 'Kaszuby', 'Roztocze'), a city ('Zakopane', 'Kraków' — covers the area around it) or a country ('Chorwacja'). Polish names work best. Omit to search everywhere. Not combinable with region.
- `region` (string): A whole voivodeship instead of a place, e.g. 'warminsko-mazurskie', 'malopolskie'. One of: dolnoslaskie, kujawsko-pomorskie, lubelskie, lubuskie, lodzkie, malopolskie, mazowieckie, opolskie, podkarpackie, podlaskie, pomorskie, slaskie, swietokrzyskie, warminsko-mazurskie, wielkopolskie, zachodniopomorskie.
- `date_from` (string): Check-in date, YYYY-MM-DD, today or later. Pass together with date_to; without dates prices are the lowest 'from' prices and availability is not checked.
- `date_to` (string): Check-out date, YYYY-MM-DD, after date_from.
- `adults` (integer): Adults. Default 2.
- `children` (integer): Children. Default 0.
- `infants` (integer): Infants (babies) — AlohaCamp does not count them toward a unit's capacity. Default 0.
- `pets` (integer): Pets travelling along; > 0 also limits results to pet-friendly places. Default 0.
- `property_types` (array): Only these kinds of stay: 'house' (domek/dom), 'tiny_house', 'tree_house', 'house_on_water' (houseboat), 'yurt', 'glamping_tent', 'agritourism' (agroturystyka/guesthouse), 'hotel', 'camper_rental' (a camper to rent), 'caravan_pitch' (a pitch for your own campervan/caravan), 'tent_pitch' (pole namiotowe). Default: everything except the two camping pitches — pass ['tent_pitch'] or ['caravan_pitch'] to search campsites.
- `amenities` (array): Must have all of these: sauna, hot_tub (balia), jacuzzi, pool, fireplace, air_conditioning, grill, campfire, wifi, workspace, washing_machine, playground, crib, adults_only; for campsites electric_hookup, shower, toilet, running_water.
- `surroundings` (array): Must be near all of these: forest, lake, mountains, sea, river, nature_reserve, village.
- `price_min` (number): Minimum nightly price in PLN.
- `price_max` (number): Maximum nightly price in PLN.
- `free_cancellation` (boolean): Only places with free cancellation. Default false.
- `page` (integer): Results page, 1-based (30 per page). Default 1.
- `no_cache` (boolean): Force a fresh fetch and bypass this server's result cache (5 min). Default false.

### alohacamp_property

Full details of one alohacamp.com property: address and coordinates, rating, description (Polish), location description, house rules, check-in/out times, cancellation policy, each unit type (capacity, rooms, beds, area), amenities, surroundings with distances, things to do, fees, meals, photos, recent reviews and nearby properties. With date_from/date_to it also prices the stay for the party: per unit whether it fits, how many are free, the minimum stay, the exact total and nightly price (PLN, incl. AlohaCamp's service fee), plus a booking link. Get the slug from alohacamp_search. Fetched live from alohacamp.com (typically 1–2 s via direct fetch; a few seconds more right after AlohaCamp deploys, or when it falls back to an unblocker). Result: { source, fetchedAt, property: { id, slug, name, url, address, lat, lng, rating, review_count, indicative_price_per_night, currency, check_in, check_in_until, check_out, free_cancellation, free_cancellation_hours, description, location_description, house_rules, units, amenities, surroundings, things_to_do, getting_there, fees, meals_available, meals_included, host, photos, recent_reviews, nearby }, stay?: { date_from, date_to, nights, adults, children, infants, pets, booking_url, units: [{ name, type, fits_party, available_units, min_nights, max_guests, total_price, price_per_night, price_from_per_night, extra_fees }], note? } }.

Parameters:
- `property` (string, required): The property's slug from alohacamp_search (e.g. 'masuria-lakehouse-518'), its alohacamp.com URL, or its numeric id.
- `date_from` (string): Check-in date, YYYY-MM-DD — pass with date_to to price the stay.
- `date_to` (string): Check-out date, YYYY-MM-DD, after date_from.
- `adults` (integer): Adults. Default 2.
- `children` (integer): Children. Default 0.
- `infants` (integer): Infants (babies) — AlohaCamp does not count them toward a unit's capacity. Default 0.
- `pets` (integer): Pets travelling along; > 0 also limits results to pet-friendly places. Default 0.
- `no_cache` (boolean): Force a fresh fetch and bypass this server's result cache (5 min). Default false.

## Gratka MCP

Endpoint: https://mcp.wondel.ai/gratka/mcp
Polish property listings on Gratka.pl and Morizon.pl (one shared database): flats, houses, plots, premises for sale or rent, with details.
Latency: <1 s, the site's own GraphQL API (direct; ZenRows fallback only on a blocked response)
Docs: https://mcps.wondel.ai/servers/gratka/
Source: Gratka.pl (https://gratka.pl), Morizon.pl (https://www.morizon.pl)

### gratka_search

Search property listings on Gratka.pl, a major Polish real-estate portal: flats, houses, plots, commercial premises, offices, garages and rooms, for sale or for rent, filtered by location (any Polish city, district, town, village, county or voivodeship), price, area, rooms, private sellers only and primary/secondary market, sorted like the site. Returns one results page (up to 35 listings) with each listing's price, price per m², area, rooms, floor, location, seller and link; pass a listing `id` to gratka_offer for the full details. Gratka.pl shows the same listings as Morizon.pl (one platform, different ids and links): search one portal, not both, and use gratka_offer only with Gratka.pl ids. Fetched live from Gratka.pl's own API (typically under 1 s). Result shape: { source, fetchedAt, query, search_url, heading, resolved_location, total_count, page, total_pages, count, listings: [...], note? } — the list key is `listings`; `total_count` counts matches across all pages (use `page` for more); `resolved_location` is the place `location` was matched to. Each listing: { source, id, url, title, category, kind, development, price, price_per_m2, currency, area_m2, rooms, floor, location, street, district, city, region, seller_type, seller_name, date_posted, refreshed_at, image, photo_count, description }. Prices are numbers in PLN (for rent, `price` is the monthly rent) and area is in m²; fields are null when the listing omits them. `kind` is 'new_development' for a developer's unit in a new project (named in `development`), else 'listing'; `seller_type` is agency | private | developer. An empty match answers count: 0 with a `note` saying why and what to change — that is a successful result, not an error.

Parameters:
- `type` (string, required): Property type: 'flat' = mieszkanie, 'house' = dom, 'plot' = działka/grunt (land), 'commercial' = lokal użytkowy (any commercial premises), 'office' = biuro, 'garage' = garaż, 'room' = pokój (a room to rent — rent only). One of: flat, house, plot, commercial, office, garage, room.
- `transaction` (string, required): 'sale' = na sprzedaż (buying), 'rent' = na wynajem (renting; prices are monthly). One of: sale, rent.
- `location` (string): Where, as a Polish place name, matched by the site's own location search: a city ('Kraków'), a district ('Warszawa Mokotów', 'Gdańsk Wrzeszcz'), a town or village, a county ('krakowski') or a whole voivodeship ('mazowieckie'). Diacritics are optional; English names other than Warsaw/Cracow are not recognised. Omit to search all of Poland.
- `price_min` (number): Minimum total price in PLN (monthly rent when transaction is 'rent').
- `price_max` (number): Maximum total price in PLN (monthly rent when transaction is 'rent').
- `area_min` (number): Minimum area in m² (the plot's area for type 'plot').
- `area_max` (number): Maximum area in m² (the plot's area for type 'plot').
- `rooms_min` (integer): Minimum number of rooms — not for types 'plot' and 'garage'.
- `rooms_max` (integer): Maximum number of rooms — not for types 'plot' and 'garage' (use min = max for exactly N).
- `private_only` (boolean): Only listings posted by private owners — no agencies or developers. Default false.
- `market` (string): 'primary' = new build from a developer (rynek pierwotny), 'secondary' = resale (rynek wtórny). One of: primary, secondary.
- `sort` (string): Order: 'newest' (recently added), 'price_asc' / 'price_desc', 'price_per_m2_asc' / 'price_per_m2_desc', 'area_asc' / 'area_desc'. Default: the site's own order (recently refreshed). One of: newest, price_asc, price_desc, price_per_m2_asc, price_per_m2_desc, area_asc, area_desc.
- `page` (integer): Results page, 1-based (35 listings per page). Default 1.
- `no_cache` (boolean): Force a fresh fetch and bypass this server's result cache (5 min). Default false.

### gratka_offer

Full details of one Gratka.pl listing: price and price per m² (PLN), area, rooms, floor, year built, property type, transaction and market, the address with district and coordinates, seller type and name (agency or developer; private owners are not named), the listing's detail tables as shown on the page (Polish labels and values: condition, rent and charges, building type, heating, ownership, available from…), amenities, the full description and photo URLs. No phone numbers. Get the id from gratka_search. Fetched live from Gratka.pl's own API (typically under 1 s). Result: { source, fetchedAt, listing: { source, id, url, title, active, property_type, transaction, market, kind, development, price, price_per_m2, currency, area_m2, rooms, floor, year_built, address, geo, seller_type, seller_name, agent_name, date_posted, updated, details, amenities, description, photos }, note? } — `note` is set when the listing is no longer active.

Parameters:
- `id` (string, required): The listing's id (e.g. '48184615') or its full https://gratka.pl link, as returned by gratka_search.
- `no_cache` (boolean): Force a fresh fetch and bypass this server's result cache (5 min). Default false.

### morizon_search

Search property listings on Morizon.pl, a major Polish real-estate portal: flats, houses, plots, commercial premises, offices, garages and rooms, for sale or for rent, filtered by location (any Polish city, district, town, village, county or voivodeship), price, area, rooms, private sellers only and primary/secondary market, sorted like the site. Returns one results page (up to 35 listings) with each listing's price, price per m², area, rooms, floor, location, seller and link; pass a listing `id` to morizon_offer for the full details. Morizon.pl shows the same listings as Gratka.pl (one platform, different ids and links): search one portal, not both, and use morizon_offer only with Morizon.pl ids. Fetched live from Morizon.pl's own API (typically under 1 s). Result shape: { source, fetchedAt, query, search_url, heading, resolved_location, total_count, page, total_pages, count, listings: [...], note? } — the list key is `listings`; `total_count` counts matches across all pages (use `page` for more); `resolved_location` is the place `location` was matched to. Each listing: { source, id, url, title, category, kind, development, price, price_per_m2, currency, area_m2, rooms, floor, location, street, district, city, region, seller_type, seller_name, date_posted, refreshed_at, image, photo_count, description }. Prices are numbers in PLN (for rent, `price` is the monthly rent) and area is in m²; fields are null when the listing omits them. `kind` is 'new_development' for a developer's unit in a new project (named in `development`), else 'listing'; `seller_type` is agency | private | developer. An empty match answers count: 0 with a `note` saying why and what to change — that is a successful result, not an error.

Parameters:
- `type` (string, required): Property type: 'flat' = mieszkanie, 'house' = dom, 'plot' = działka/grunt (land), 'commercial' = lokal użytkowy (any commercial premises), 'office' = biuro, 'garage' = garaż, 'room' = pokój (a room to rent — rent only). One of: flat, house, plot, commercial, office, garage, room.
- `transaction` (string, required): 'sale' = na sprzedaż (buying), 'rent' = na wynajem (renting; prices are monthly). One of: sale, rent.
- `location` (string): Where, as a Polish place name, matched by the site's own location search: a city ('Kraków'), a district ('Warszawa Mokotów', 'Gdańsk Wrzeszcz'), a town or village, a county ('krakowski') or a whole voivodeship ('mazowieckie'). Diacritics are optional; English names other than Warsaw/Cracow are not recognised. Omit to search all of Poland.
- `price_min` (number): Minimum total price in PLN (monthly rent when transaction is 'rent').
- `price_max` (number): Maximum total price in PLN (monthly rent when transaction is 'rent').
- `area_min` (number): Minimum area in m² (the plot's area for type 'plot').
- `area_max` (number): Maximum area in m² (the plot's area for type 'plot').
- `rooms_min` (integer): Minimum number of rooms — not for types 'plot' and 'garage'.
- `rooms_max` (integer): Maximum number of rooms — not for types 'plot' and 'garage' (use min = max for exactly N).
- `private_only` (boolean): Only listings posted by private owners — no agencies or developers. Default false.
- `market` (string): 'primary' = new build from a developer (rynek pierwotny), 'secondary' = resale (rynek wtórny). One of: primary, secondary.
- `sort` (string): Order: 'newest' (recently added), 'price_asc' / 'price_desc', 'price_per_m2_asc' / 'price_per_m2_desc', 'area_asc' / 'area_desc'. Default: the site's own order (recently refreshed). One of: newest, price_asc, price_desc, price_per_m2_asc, price_per_m2_desc, area_asc, area_desc.
- `page` (integer): Results page, 1-based (35 listings per page). Default 1.
- `no_cache` (boolean): Force a fresh fetch and bypass this server's result cache (5 min). Default false.

### morizon_offer

Full details of one Morizon.pl listing: price and price per m² (PLN), area, rooms, floor, year built, property type, transaction and market, the address with district and coordinates, seller type and name (agency or developer; private owners are not named), the listing's detail tables as shown on the page (Polish labels and values: condition, rent and charges, building type, heating, ownership, available from…), amenities, the full description and photo URLs. No phone numbers. Get the id from morizon_search. Fetched live from Morizon.pl's own API (typically under 1 s). Result: { source, fetchedAt, listing: { source, id, url, title, active, property_type, transaction, market, kind, development, price, price_per_m2, currency, area_m2, rooms, floor, year_built, address, geo, seller_type, seller_name, agent_name, date_posted, updated, details, amenities, description, photos }, note? } — `note` is set when the listing is no longer active.

Parameters:
- `id` (string, required): The listing's id (e.g. 'mzn2047996834') or its full https://www.morizon.pl link, as returned by morizon_search.
- `no_cache` (boolean): Force a fresh fetch and bypass this server's result cache (5 min). Default false.

## OLX MCP

Endpoint: https://mcp.wondel.ai/olx/mcp
OLX.pl classifieds in every category — property to rent or buy, cars, electronics, jobs, free items — plus offer details.
Latency: <1 s, direct fetch of OLX's public JSON API (Firecrawl/Bright Data fallback only on a block)
Docs: https://mcps.wondel.ai/servers/olx/
Source: OLX.pl (https://www.olx.pl)

### olx_search

Search offers on OLX.pl, Poland's largest classifieds site, across every category: flats and houses for rent or sale, cars and parts, phones and electronics, furniture, clothes, jobs, services, free items. Filter by words, category, place (city or district, with a radius) or voivodeship, price range, new/used, private vs business seller, and any category-specific attribute via `filters`. Common category_id values: Nieruchomości 3 (flats for rent 15, flats for sale 14, houses for rent 20, houses for sale 18, rooms 11, plots 709), Motoryzacja 5 (passenger cars 84, motorcycles 81, car parts 82), Elektronika 99 (smartphones 1839, laptops 1199, TVs 1849, game consoles 1604), Dom i Ogród 628 (furniture 565), Moda 87, Dla Dzieci 88, Sport i Hobby 767 (bicycles 461), Zwierzęta 103, Praca 4 (jobs), Usługi 4371, Oddam za darmo 1151 (free items). olx_categories lists the full tree and shows which categories a query's offers fall in. Pass an offer's `id` to olx_offer for the full description, all photos and map location. Fetched live from OLX.pl's public API (typically well under 1 s; a few seconds when it falls back to an unblocker). Result shape: { source, fetchedAt, query, resolved_location, total_count, offset, limit, next_offset, count, offers: [...], note? } — the list key is `offers`; `total_count` counts all matches, but OLX pages through only the first 1000 (pass `next_offset` as `offset` for more). Each offer: { id, url, title, price: { value, currency, negotiable, type, label, per?, previous_value? } | null, salary?, area_m2?, rooms?, params, city, district, region, category_id, category, seller_type, promoted, created_time, refreshed_time, photo, photos_count, description, external_url? }. `price.value` is a number in `currency` (PLN) or null when there is no amount. `price.type`: 'price' = the asking price (`negotiable` when the seller accepts offers; for flat/house rentals the monthly rent), 'arranged' (to be agreed) with value null, 'budget' = the advertiser's budget rather than an asking price, 'free' = giveaway with value 0, 'exchange' = swap with value null — so never read a missing amount as 0 PLN. `per` ('hour' | 'day' | 'night' | 'week' | 'month') marks a rate, e.g. equipment rented at 150 PLN per day — the value is then not a total. `previous_value` appears after a price drop. Jobs carry `salary` { from, to, currency, period, gross } instead of a price. `params` maps each attribute's key to its Polish display label (e.g. { state: 'Używane', m: '44,60 m²', rooms: '2 pokoje' }) — the keys are what `filters` use. `description` is a short excerpt; contact details are never included. An empty match answers count: 0 with a `note` saying why and what to change — a successful result, not an error.

Parameters:
- `query` (string): Search words, matched loosely against titles and descriptions. Polish terms work best ('rower górski', 'kawalerka', 'iphone 13 pro'). Omit to browse a category/place.
- `category_id` (integer): OLX category id (see the list above or olx_categories), e.g. 15 = flats for rent.
- `location` (string): Polish name of a city, town or village, optionally followed by a district: 'Kraków', 'Warszawa Mokotów', 'Gdańsk Wrzeszcz'. English names ('Warsaw') are not recognised; a partial name returns suggestions. Same-name villages: add region to choose.
- `region` (string): Voivodeship. Alone: search the whole voivodeship. With location: picks among same-name places. One of: dolnoslaskie, kujawsko-pomorskie, lubelskie, lubuskie, lodzkie, malopolskie, mazowieckie, opolskie, podkarpackie, podlaskie, pomorskie, slaskie, swietokrzyskie, warminsko-mazurskie, wielkopolskie, zachodniopomorskie.
- `distance_km` (integer): Also include offers within this radius of location, in km (OLX offers 2, 5, 10, 15, 30, 50, 75, 100).
- `price_from` (number): Minimum price in PLN (monthly rent for rentals).
- `price_to` (number): Maximum price in PLN (monthly rent for rentals).
- `condition` (string): Item condition (Stan) — goods categories only (electronics, fashion, home…). One of: new, used.
- `owner_type` (string): 'private' = private individuals only; 'business' = companies/agencies only. One of: private, business.
- `sort_by` (string): 'relevance', 'newest' (most recently posted or refreshed first), 'price_asc' (cheapest first) or 'price_desc'. Default: OLX's own ordering. One of: relevance, newest, price_asc, price_desc.
- `filters` (object): Category-specific OLX filters (requires category_id). Keys come from an offer's `params` keys: 'filter_float_<key>:from' / ':to' for numbers, 'filter_enum_<key>' for choices (value or list of option keys). Examples — flats: { 'filter_float_m:from': 40, 'filter_float_m:to': 60, 'filter_enum_rooms': ['two', 'three'], 'filter_enum_furniture': 'yes' }; cars (84): { 'filter_float_year:from': 2018, 'filter_float_milage:to': 100000, 'filter_enum_petrol': 'diesel' }. OLX rejects a key the category does not have.
- `include_promoted` (boolean): Also return OLX's paid top-ad slots (flagged promoted: true). They repeat across pages and ignore sort_by, so they are left out by default.
- `offset` (integer): Skip this many results (0–1000; OLX pages through the first 1000 only). Default 0.
- `limit` (integer): Results per call, 1–50. Default 20.
- `no_cache` (boolean): Force a fresh fetch and bypass this server's result cache (5 min). Default false.

### olx_offer

Full details of one OLX.pl offer: price (or salary for a job), every attribute with its Polish name and value (area, rooms, rent, condition, model, year, mileage…), the full description, all photo URLs, location (city, district, voivodeship, map coordinates — often approximate), seller type and public name (company, or the first name a private seller shows), posting/refresh/expiry times, OLX delivery availability, and the original otodom.pl link for partner property listings. No contact details. Fetched live from OLX.pl's public API (typically well under 1 s; a few seconds when it falls back to an unblocker). Result: { source, fetchedAt, offer: { id, url, title, status, category_id, category, price, salary?, area_m2?, rooms?, params: [{ key, name, value }], description, location: { city, city_id, district, district_id, region, region_id, lat, lon, approximate }, seller: { type, name, member_since }, created_time, refreshed_time, valid_to_time, promotion, olx_delivery, photos, external_url } }.

Parameters:
- `id` (string|integer, required): The offer's numeric id (e.g. 1100381308) or its OLX URL (…-CID3-ID1ct5rC.html), as returned by olx_search.
- `no_cache` (boolean): Force a fresh fetch and bypass this server's result cache (5 min). Default false.

### olx_categories

Find the category_id for olx_search. Without arguments: OLX's 19 top-level categories. With parent_id: that category's sub-categories (instant, from a snapshot of OLX's category tree). With query: which categories the offers matching those words fall in, with live offer counts, largest first — the quickest way to pick a category for a search term (e.g. 'iphone 13' → Smartfony i telefony komórkowe > iPhone). Result: { source, parent, query?, total_count?, count, categories: [{ id, name, path, has_children, count? }] } — `path` is the full Polish name trail ('Nieruchomości > Mieszkania > Wynajem').

Parameters:
- `parent_id` (integer): List this category's sub-categories (e.g. 3 = Nieruchomości). With query: scope the counts to it.
- `query` (string): Search words; returns the categories their offers fall in, with counts (one live request).
- `no_cache` (boolean): Force a fresh fetch and bypass this server's result cache (5 min). Default false.

## Otodom MCP

Endpoint: https://mcp.wondel.ai/otodom/mcp
Polish property listings on Otodom.pl: flats, houses, rooms, plots, commercial for sale or rent, plus full offer details.
Latency: ~0.3–1 s, direct fetch of the site's Next.js JSON routes (page HTML via unblocker only when blocked, ~6 s)
Docs: https://mcps.wondel.ai/servers/otodom/
Source: Otodom (https://www.otodom.pl)

### otodom_search

Search property listings on otodom.pl, Poland's largest real-estate portal: flats, studios, houses, rooms, plots, commercial premises, warehouses, garages and developers' new projects, for sale or for rent. Filter by place (a city, 'city district', town, village or voivodeship, resolved by Otodom's own location search), price, area, rooms, private-owner vs agency listings and primary/secondary market; sort by newest, price or area. Returns one results page (24 by default) with each listing's price, czynsz, price per m², area, rooms, floor, place, seller type and link; pass a listing's `slug` to otodom_offer for full details. Fetched live from otodom.pl (typically 0.3–1 s via direct fetch; ~5–10 s when it falls back to an unblocker). Result shape: { source, fetchedAt, query, search_url, heading, resolved_location, other_locations?, total_count, page, page_size, total_pages, count, listings: [...], note?, warning? } — the list key is `listings`; `total_count` counts matches across all pages (use `page` for more). Each listing: { id, slug, url, title, kind, price, rent_extra, price_per_m2, currency, price_on_request, area_m2, plot_area_m2, rooms, floor, location, street, district, city, region, location_id, seller_type, agency_name, features, is_promoted, date_created, image, photos_count, description, development? }. Prices are numbers in PLN: for rentals `price` is the monthly rent, and `rent_extra` is the monthly administrative fee (czynsz) paid on top (stated on sales too); `price` is null with price_on_request true when the advertiser hides it. `floor` is 'ground', '1'…'10', '10+', 'basement' or 'attic'. `kind` is 'new_development' for a developer's project (its units' ranges in `development`), else 'listing'; `seller_type` is private | agency | developer. `resolved_location` says which place was searched — check it; `other_locations` lists other matches for the name (pass one's `id` as `location`). An empty match answers count: 0 with a `note` saying why and what to change — that is a successful result, not an error.

Parameters:
- `transaction` (string, required): 'sale' = na sprzedaż (buying), 'rent' = na wynajem (renting; prices are monthly). One of: sale, rent.
- `type` (string, required): Property type: 'flat' = mieszkanie, 'studio' = kawalerka (one-room flat), 'house' = dom, 'room' = pokój (rent only), 'plot' = działka (land), 'commercial' = lokal użytkowy (office, shop, premises), 'warehouse' = hala/magazyn, 'garage' = garaż/miejsce parkingowe, 'new_development' = a developer's project (inwestycja; sale only). One of: flat, studio, house, room, plot, commercial, warehouse, garage, new_development.
- `location` (string): Where, in Polish spelling as the site uses it: a city ('Warszawa', 'Kraków'), 'city district' ('Warszawa Mokotów', 'Gdańsk Wrzeszcz'), a town or village ('Zakopane'), or a voivodeship ('mazowieckie'). English names ('Warsaw') are not recognised. Also accepts an Otodom location id (slug path) from a previous result's `location_id`/`resolved_location.id`, e.g. 'mazowieckie/warszawa/warszawa/warszawa/mokotow'. Omit to search all of Poland.
- `price_min` (number): Minimum price in PLN (the monthly rent when transaction is 'rent').
- `price_max` (number): Maximum price in PLN (the monthly rent when transaction is 'rent').
- `area_min` (number): Minimum area in m² (the plot's area for type 'plot').
- `area_max` (number): Maximum area in m² (the plot's area for type 'plot').
- `rooms_min` (integer): Minimum number of rooms — types 'flat' and 'house' only.
- `rooms_max` (integer): Maximum number of rooms — types 'flat' and 'house' only (min = max for exactly N). Otodom's filter stops at '6 or more', so any bound of 6+ means 6 or more.
- `owner_type` (string): 'private' = only listings posted by private owners (bez pośredników), 'agency' = only agencies and developers (sales only — Otodom has no agency-only filter for rentals), 'all' (default). One of: all, private, agency.
- `market` (string): Sales only: 'primary' = new-build from a developer (rynek pierwotny), 'secondary' = resale (rynek wtórny). Omit for both. One of: primary, secondary.
- `sort` (string): Order: 'relevance' (Otodom's default, promoted listings first), 'newest', 'oldest', 'price_asc', 'price_desc', 'area_asc', 'area_desc'. One of: relevance, newest, oldest, price_asc, price_desc, area_asc, area_desc.
- `page` (integer): Results page, 1-based. Default 1.
- `limit` (integer): Listings per page; rounded up to a size Otodom serves (24, 36, 48 or 72). Default 24.
- `no_cache` (boolean): Force a fresh fetch and bypass this server's result cache (5 min). Default false.

### otodom_offer

Full details of one otodom.pl listing (or a developer's project page): price, czynsz (rent_extra) and deposit (PLN), price per m², area and plot area, rooms, floor and the building's floor count, year built, building type and material, heating, ownership, condition, windows, energy certificate, availability date, market, address with district and coordinates, seller type and agency name, amenities/equipment as `features`, every other stated attribute in `details`, the full description and photo URLs. Contact phone numbers are not returned. For a development project, `development` gives its unit count, area range and completion date. Get the slug from otodom_search. Fetched live from otodom.pl (typically 0.3–1 s via direct fetch; ~5–10 s when it falls back to an unblocker). Result: { source, fetchedAt, offer: { id, slug, url, title, status, type, transaction, kind, market, price, rent_extra, deposit, price_per_m2, currency, price_on_request, area_m2, plot_area_m2, rooms, floor, floors_in_building, year_built, building_type, building_material, heating, ownership, condition, windows, energy_certificate, available_from, address, location_id, geo, seller_type, agency_name, agency_url, date_created, date_modified, features, details, description, photos, development? } }. Codes such as heating 'urban' (district heating) or condition 'ready_to_use' are Otodom's own. A removed listing is an error that says so.

Parameters:
- `offer` (string, required): The listing's slug from otodom_search (ends in -ID<code>, e.g. 'mieszkanie-4-pokojowe-w-mokotowie-z-balkonem-ID4sFig') or its otodom.pl URL (/pl/oferta/… or /pl/inwestycja/…).
- `no_cache` (boolean): Force a fresh fetch and bypass this server's result cache (5 min). Default false.

## Airbnb MCP

Endpoint: https://mcp.wondel.ai/airbnb/mcp
Airbnb stays worldwide: search by place, dates and guests with total prices, ratings and links, plus one listing's details.
Latency: ~1–2 s, direct fetch of airbnb.pl pages (Firecrawl fallback only on a challenge page, ~8 s); listing price = 2 requests
Docs: https://mcps.wondel.ai/servers/airbnb/
Source: Airbnb (https://www.airbnb.pl)

### airbnb_search

Search places to stay on Airbnb — apartments, houses, rooms, cabins, villas and hotels — in any city, region or country, for given dates and guests: price for the stay, rating and review count, Guest favourite / Superhost badges, beds and baths, coordinates, photos and a link that opens the same stay. Filter by room type, minimum bedrooms and total price. One page is up to 18 stays; `page` 2–15 for more (Airbnb caps a search at 270). Pass a listing's `id` to airbnb_listing for amenities, house rules and the host. Scraped live from airbnb.pl (typically ~1 s via direct fetch; ~10 s when it falls back to an unblocker). WITH checkin + checkout, `price` is the TOTAL for the whole stay for the given guests, all fees and taxes included (Airbnb's EU total-price display), in `currency`; `price_per_night` = price ÷ nights; `price_before_discount` is the struck-through total when discounted; `price_breakdown` lists Airbnb's own lines (e.g. '2 noce x 245,00 zł' → 490, 'Podatki' → 8). Stays of 28+ nights are quoted per month: `price` null, `price_per_month` set. WITHOUT dates, Airbnb prices each listing for its own suggested stay (its `stay`, usually ~5 nights soon), so prices are not comparable and not a quote — a `note` says so; pass dates to quote a trip. Only stays bookable for the given dates are listed. Result shape: { source, fetchedAt, query, search_url, place: { query, place_id, resolved, city, region, country }, stay: { checkin, checkout, nights } | null, guests: { adults, children, infants, pets }, currency, total_count, page, total_pages, count, listings: [...], note? } — the list key is `listings`; `total_count` is Airbnb's count of matches (more than it lets you page through). Each listing: { id, url, name, kind, city, details, bedrooms, beds, baths, host_type, rating, review_count, is_new, guest_favorite, superhost, badges, free_cancellation, stay, price_basis, price, price_per_night, price_per_month, price_before_discount, nights, currency, price_text, price_breakdown, lat, lng, photos }. `rating` is 0–5; `kind`/`city`/`details`/`price_text` are Airbnb's Polish wording (e.g. kind 'Mieszkanie' = apartment, 'Pokój' = room, 'Dom' = house); `host_type` is business | private; coordinates are approximate (Airbnb blurs them). An empty match answers count: 0 with a `note` saying why and what to change — that is a successful result, not an error.

Parameters:
- `place` (string, required): Where to stay — a city, region, area or country, as you would type it into Airbnb: 'Zakopane', 'Kraków', 'Mazury', 'Lisbon, Portugal', 'Tuscany'. Add the country to disambiguate. Latin script (diacritics are fine).
- `checkin` (string): Arrival date, YYYY-MM-DD (from today to about two years ahead). Pass together with checkout; omit both for Airbnb's own suggested dates.
- `checkout` (string): Departure date, YYYY-MM-DD, after checkin (at most 365 nights; 28+ nights are quoted per month).
- `adults` (integer): Adults (13+). Default 2.
- `children` (integer): Children aged 2–12. adults + children ≤ 16. Default 0.
- `infants` (integer): Infants under 2 (not counted as guests). Default 0.
- `pets` (integer): Pets (limits results to pet-friendly stays). Default 0.
- `currency` (string): 3-letter ISO currency for prices, e.g. 'PLN' (default), 'EUR', 'USD', 'GBP'.
- `room_type` (string): Only 'entire_home' (the whole place to yourself) or only 'private_room'. Default: any. One of: entire_home, private_room.
- `min_bedrooms` (integer): At least this many bedrooms.
- `price_min` (integer): Minimum total price for the whole stay incl. fees, whole units of `currency` (needs dates).
- `price_max` (integer): Maximum total price for the whole stay incl. fees, whole units of `currency` (needs dates).
- `page` (integer): Results page, 1-based (18 stays per page, at most 15 pages). Default 1.
- `no_cache` (boolean): Force a fresh fetch and bypass this server's result cache (5 min). Default false.

### airbnb_listing

Full details of one Airbnb listing: name, type, capacity, bedrooms/beds/baths, sleeping arrangements, amenities (and notable ones missing), description (trimmed), house rules with check-in/check-out times, the host (name, Superhost, company or individual, years hosting, response rate — no contact details), the rating with its categories, approximate location, highlights and photos. With checkin/checkout it also returns the price for that stay and guests — the TOTAL incl. all fees (`price`), `price_per_night`, `price_before_discount`, `price_breakdown` — and `available`: false when the listing cannot be booked for those dates or that many guests (the note says why). Without dates there is no price (Airbnb prices only dated stays). Scraped live from airbnb.pl (typically ~1 s via direct fetch; ~10 s when it falls back to an unblocker). Two requests with dates (the page, then a dated search around it for the price). Result: { source, fetchedAt, query, page_url, listing: { id, url, name, kind, room_type, property_type, summary, overview, capacity, bedrooms, beds, baths, location: { name, lat, lng, approximate }, rating, review_count, rating_categories, guest_favorite, is_new, host: { name, superhost, verified, business, years_hosting, rating, review_count, response_rate, response_time, about }, description, checkin_from, checkin_until, checkout_by, house_rules, additional_rules, sleeping: [{ room, beds }], amenities, amenities_not_included, highlights, photos, stay, guests, available, free_cancellation, price_basis, price, price_per_night, price_per_month, price_before_discount, nights, currency, price_text, price_breakdown }, note? }. Text fields are Airbnb's Polish wording.

Parameters:
- `listing` (string, required): The listing: its `id` from airbnb_search (e.g. '49891381') or its link from any Airbnb domain (https://www.airbnb.pl/rooms/49891381, https://www.airbnb.com/rooms/49891381).
- `checkin` (string): Arrival date, YYYY-MM-DD (from today to about two years ahead). Pass together with checkout; omit both for Airbnb's own suggested dates.
- `checkout` (string): Departure date, YYYY-MM-DD, after checkin (at most 365 nights; 28+ nights are quoted per month).
- `adults` (integer): Adults (13+). Default 2.
- `children` (integer): Children aged 2–12. adults + children ≤ 16. Default 0.
- `infants` (integer): Infants under 2 (not counted as guests). Default 0.
- `pets` (integer): Pets (limits results to pet-friendly stays). Default 0.
- `currency` (string): 3-letter ISO currency for prices, e.g. 'PLN' (default), 'EUR', 'USD', 'GBP'.
- `no_cache` (boolean): Force a fresh fetch and bypass this server's result cache (5 min). Default false.

## Slowhop MCP

Endpoint: https://mcp.wondel.ai/slowhop/mcp
Slow stays on Slowhop.com: cabins, agritourism, glamping and guesthouses in nature, mostly in Poland, priced for your dates, party and pets (PLN).
Latency: <1 s, the site's own JSON API (direct; ZenRows fallback only on a blocked response)
Docs: https://mcps.wondel.ai/servers/slowhop/
Source: Slowhop (https://slowhop.com)

### slowhop_search

Search slowhop.com, the Polish marketplace of 'slow' stays: houses and cabins in nature, agritourism, guesthouses, glamping, tiny houses and apartments with character, mostly in Poland (some in Czechia, Slovakia, Italy, Croatia…). Filter by place (region, town, country or a landscape word), check-in/check-out dates and party — adults, children's ages, pets (with dates only places free for that party are returned, priced for it) — plus Slowhop's own filters (by a lake, by the sea, in the mountains, sauna, hot tub, breakfast, pets welcome…), a nightly price range and last-/first-minute deals; sort by recommendation or price. Returns one page (24 by default) in Slowhop's order; pass a listing's `slug` to slowhop_place for the description, units, house rules, pets policy and the exact price breakdown. Fetched live from Slowhop's own JSON API (typically well under 1 s via direct fetch; more when it falls back to an unblocker). Result shape: { source, fetchedAt, query, search_url, resolved_place: { name, kind, radius_km? } | null, alternatives?, stay: { date_from, date_to, nights } | null, guests: { adults, children_ages, pets }, total_count, page, total_pages, count, listings: [...], note? } — the list key is `listings`; `total_count` counts matches across all pages (use `page` for more). Each listing: { available, restriction, id, slug, name, url, type, type_key, city, region, country, summary, price, price_per_night, price_per_night_before_discount, currency, cheapest_dates, meal_plan, max_guests, units_for_party, rating, reviews_count, instant_booking, only_on_slowhop, for_whom, host, image }. Prices are numbers in the listing's `currency` — PLN for places in Poland, usually EUR abroad — for the WHOLE party, never per person. WITH date_from + date_to: `price_per_night` is Slowhop's nightly price for this party averaged over the stay (it already includes cleaning, pet and children's fees) and `price` = price_per_night × nights, the total for the whole stay (within a few zł of the booking total; slowhop_place with the same dates gives the exact breakdown); `units_for_party` > 1 means it covers several houses/rooms; `url` opens the place with the same stay. Dated, the site also lists places it cannot book exactly as asked — each listing's `available` is true (bookable as asked) or false, with `restriction` { type: min_nights | max_nights | arrival_impossible | departure_impossible | stay_impossible, min_nights, max_nights } saying why; those have price null (price_per_night stays their nightly rate for those dates), come last, and the `note` counts them — never quote an available: false place for the dates asked; slowhop_place with the same dates gives the exact quote before booking. WITHOUT dates `available` is null, `price` is null, `price_per_night` is the lowest upcoming nightly price and `cheapest_dates` says for which stay; availability is not checked (the `note` says so). `price_per_night_before_discount` is set during a last-/first-minute discount. `meal_plan` is none | breakfast | half_board | full_board | all_inclusive; `rating` is 0–5 (null without reviews). An empty match answers count: 0 with a `note` saying why and what to change — that is a successful result, not an error.

Parameters:
- `place` (string): Where, resolved by Slowhop's own autocomplete: a region ('Mazury', 'Bieszczady', 'Kaszuby', 'Tatry', 'Roztocze', 'Toskania'), a town ('Zakopane', 'Kazimierz Dolny' — searched within radius_km), a country ('Chorwacja', 'Włochy'), or a landscape word ('góry', 'morze', 'jezioro', 'las', 'wieś' → Poland with that setting filter). Polish names work best. Omit to search everywhere.
- `radius_km` (integer): Around a town only: search radius in km (default: the site's own, 20 km for a town).
- `date_from` (string): Check-in date, YYYY-MM-DD, today or later. Pass together with date_to; without dates prices are the lowest upcoming 'from' prices and availability is not checked.
- `date_to` (string): Check-out date, YYYY-MM-DD, after date_from (at most 60 nights).
- `adults` (integer): Adults. Default 2.
- `children_ages` (array): Each child's age in years (0–17), e.g. [4, 9] for two children — prices depend on ages. Default none.
- `pets` (array): The animals coming along, one entry each: 'small_dog', 'medium_dog', 'big_dog', 'cat' (e.g. ['big_dog', 'cat']). Also limits results to places that accept them. Default none.
- `filters` (array): Slowhop's own filter ids. Alternatives of one kind match ANY — settings, types, who-for, accepted pets, the wellness facilities sauna/wooden_bath/pool/jacuzzi/bathtube/massages — while different kinds must ALL match (['lake', 'sauna'] = by a lake AND with a sauna; ['sauna', 'jacuzzi'] = either): the site's own logic. Setting: lake, sea, mountain, forest, countryside, shoreline, river, city. Type: agro_guesthouse (agritourism, guesthouse), cottages (houses incl. tiny houses), tiny_house, camping (glamping/camping), hotels, city_apartments, hostels, campers, yachts. Who for: children_loving, couples, without_neighbors, adults (adults and teens only), rarities, unique_view, good_design, modern_architecture, idyllic, historical_places, fixer_upper, pet-free, lots_of_animals, single, disability, celebrations, workshops_and_conferences. Food: breakfast, meals (meals on site), restaurant, kitchen_available, vegetarian, vegan, special_diets. Pets: small_dogs, medium_dogs, big_dogs, cats, fenced_area, leash_free. Wellness: sauna, wooden_bath (outdoor hot tub, 'balia'), pool, jacuzzi, bathtube, massages, fireplace. Active: forest-trails, trail (mountain trail), skiing-slope, running-ski (cross-country skiing), horseriding, kayaks, fishing, bikes_onsite. Other: solo / groups (workation), fast_internet, no_internet, electric-car-charger, kids-playground.
- `sort` (string): 'recommended' (Slowhop's order, default), 'price_asc' or 'price_desc' (by nightly price). One of: recommended, price_asc, price_desc.
- `price_min` (number): Minimum nightly price for the whole party, in PLN (Slowhop converts foreign prices).
- `price_max` (number): Maximum nightly price for the whole party, in PLN (Slowhop converts foreign prices).
- `last_minute` (boolean): Only last-minute deals. Default false.
- `first_minute` (boolean): Only first-minute (early booking) deals. Default false.
- `page` (integer): Results page, 1-based. Default 1.
- `limit` (integer): Places per page, 1–48. Default 24.
- `no_cache` (boolean): Force a fresh fetch and bypass this server's result cache (5 min). Default false.

### slowhop_place

Full details of one slowhop.com place: type, summary, highlights and the host's description (Polish), address and coordinates, setting, rating and recent reviews, every unit (house/room/tent: capacity, area, rooms and beds, pets accepted), check-in/out times and quiet hours, house rules, pets policy (kinds accepted, limit, rules), who it suits, food and kitchen, amenities (comfort, kitchen, garden, wellness included, extra-paid extras with prices), internet, nearby activities/restaurants/shops/sights with distances, getting there, fees, discounts (last-/first-minute, long stay, children), payment and cancellation terms, the lowest upcoming price and photos. With date_from/date_to it also prices the stay for the party with Slowhop's own calculator: whether it is bookable (free, minimum stay met, the group and pets fit), the exact total and per-night price in the place's currency (PLN in Poland) with a breakdown, the units used and a booking link. Get the slug from slowhop_search. Fetched live from Slowhop's own JSON API (typically well under 1 s via direct fetch; more when it falls back to an unblocker). Result: { source, fetchedAt, place: { id, slug, name, url, type, currency, summary, highlights, description, texts, location, rating, reviews_count, recent_reviews, host, max_guests, min_age, units, rent_type, check_in, check_out, quiet_hours, flexible_check_in, pets, house_rules, for_whom, food, amenities, internet, nearby, getting_there, fees, discounts, payment, lowest_price, instant_booking, photos }, stay?: { date_from, date_to, nights, adults, children_ages, pets, available, price, price_per_night, currency, breakdown: { nightly_rates, last_minute_discount, first_minute_discount, children_discount, children_fee, cleaning_fee, pets_fee }, meal_plan, min_nights, units, booking_url, calculator_quote?, note? } }. `stay.price` is the total for the whole stay and party (nightly rates after discounts + children's, cleaning and pet fees); `stay.available` is true, false (a `note` says why and what to change) or null when Slowhop's availability calendar did not answer (priced, but the minimum stay is unverified). When `available` is false, `price`, `price_per_night` and `breakdown` are null and `units` empty — never quote such a stay; if Slowhop's calculator still priced it (it ignores minimum stays and pets a place refuses), its figures are in `calculator_quote` { price, price_per_night, breakdown, units, note } for reference only.

Parameters:
- `place` (string, required): The place's slug from slowhop_search (e.g. '6639-dom-na-mazurach-sasek-wielki'), its slowhop.com URL (…/pl/miejsca/<slug>.html), or its numeric id.
- `date_from` (string): Check-in date, YYYY-MM-DD — pass with date_to to price the stay.
- `date_to` (string): Check-out date, YYYY-MM-DD, after date_from.
- `adults` (integer): Adults. Default 2.
- `children_ages` (array): Each child's age in years (0–17), e.g. [4, 9] for two children — prices depend on ages. Default none.
- `pets` (array): The animals coming along, one entry each: 'small_dog', 'medium_dog', 'big_dog', 'cat' (e.g. ['big_dog', 'cat']). Also limits results to places that accept them. Default none.
- `no_cache` (boolean): Force a fresh fetch and bypass this server's result cache (5 min). Default false.

## Amazon MCP

Endpoint: https://mcp.wondel.ai/amazon/mcp
Amazon product search on 22 country stores, multi-store price comparison and one product's offers, every price in PLN (NBP rates).
Latency: ~1.5–4 s per search via SerpAPI; amazon_compare runs its stores in parallel (1 credit each); amazon_product ~10–25 s
Docs: https://mcps.wondel.ai/servers/amazon/
Source: Amazon (https://www.amazon.de), Narodowy Bank Polski (exchange rates) (https://api.nbp.pl)

### amazon_search

Search one Amazon store (22 countries; default amazon.pl) via SerpAPI, with every price also in PLN at the official NBP mid rate. Costs one SerpAPI credit per call (a repeat within 5 minutes is cached and free). Refine with sort, page, min_price/max_price (store currency; enforced on the displayed price), brand, category_node, min_rating/min_reviews (applied to the returned page), include_sponsored, and any refinement Amazon offers on that page via `rh`: the result's `filters` lists each option's rh (Prime, 4★ & up, New condition, sold by Amazon, deals, features…) — pass them comma-separated. A store printing PLN itself (shipping_location 'PL' on a foreign store) is taken as-is. Use amazon_compare for several stores at once and amazon_product for one ASIN's offers, sellers and specs. Result shape: { source, fetchedAt, query, marketplace: { code, domain, country, currency, language }, search_url, total_results (Amazon's own count, before this page's post-filters), query_displayed?, page, next_page, count, products: [...], filters?: { <group>: [{ name, rh }] }, categories?: [{ name, node }], related_searches?, fx: [{ currency, rate, table, table_no, effective_date, source: 'NBP' }], note? } — the list key is `products`. Each product: { position, asin, title, brand?, url (https://www.<store>/dp/<ASIN>), image?, price (number, in `currency`), price_text (as displayed), currency (ISO, read from the displayed price), price_pln, old_price?, discount_percent?, rating, reviews, bought_last_month?, prime? (only stores that mark it), sponsored, badges?, delivery?, stock?, coupon?, offers?, more_buying_choices?, variants?: [{ asin, title }], purchase_options? }. price_pln is null when there is no price or no NBP rate (the note says why). A search Amazon answers with nothing is count: 0 plus a note on what to relax — a successful result, not an error.

Parameters:
- `query` (string): What you'd type in Amazon's search box, e.g. 'sony wh-1000xm5'. Required unless category_node is set.
- `marketplace` (string): Amazon store: its code (pl, de, fr, it, es, nl, be, se, uk, tr, us, ca, mx, br, au, jp, in, cn, sg, ae, sa, eg) or domain (amazon.de, amazon.co.uk…). Default pl.
- `language` (string): Store language as <language>_<REGION>, e.g. 'en_GB' for English titles on amazon.de. Default: the store's own (de_DE on amazon.de) — each store only offers a few (amazon_marketplaces lists them).
- `sort` (string): Amazon's sort: relevance (default, Amazon's 'Featured'), price_asc, price_desc, rating (avg. customer review), newest, bestsellers. The price sorts are re-applied to the returned page by displayed price (Amazon sorts by its offer prices), with products that show no price listed last. One of: relevance, price_asc, price_desc, rating, newest, bestsellers.
- `page` (integer): Result page, 1–20. Default 1.
- `min_price` (number): Lowest price in the STORE's currency (EUR on amazon.de). Sent to Amazon, then enforced on the displayed price: out-of-range products and products without a price are dropped (the note counts them).
- `max_price` (number): Highest price in the store's currency, applied like min_price.
- `brand` (string): One brand name as Amazon spells it, e.g. 'Sony' (Amazon's brand filter).
- `category_node` (string): Amazon browse-node id (digits) to search within — from a result's `categories`, or node=… in an Amazon category URL. Ids differ per store. Without a query this browses the category.
- `rh` (string): Amazon refinements, comma-separated key:value pairs exactly as a previous result's `filters` list them (e.g. 'p_n_condition-type:776949031,p_72:419117031'). Ids are store-specific.
- `exclude_autocorrected` (boolean): Drop results Amazon adds from an auto-corrected spelling of the query. Default false.
- `shipping_location` (string): Deliver-to country as an ISO code, e.g. 'PL': a foreign store then lists only items it delivers there, adds delivery cost to `delivery`, and usually prints prices already converted to PLN by Amazon (VAT of the destination). 'local' (or omitted) = the store's own country.
- `delivery_zip` (string): Delivery postal code within shipping_location's country (or the store's), e.g. '00-001'.
- `min_rating` (number): Keep products rated at least this (0–5), filtered on the returned page.
- `min_reviews` (integer): Keep products with at least this many ratings, filtered on the returned page.
- `include_sponsored` (boolean): Keep sponsored slots (marked sponsored: true). Default false — ads repeat and distort ranking.
- `include_filters` (boolean): Return the page's refinement `filters` (name + rh per option). Default true.
- `limit` (integer): Max products returned (1–60). Default 20.
- `convert_to_pln` (boolean): Add price_pln at the NBP mid rate. Default true.
- `no_cache` (boolean): Force a fresh SerpAPI fetch, bypassing this server's 5-minute result cache. Default false.

### amazon_compare

Run one query on several Amazon stores in parallel (default pl, de, fr, it, es, nl; at most 10) and merge the results in PLN — the cheapest first by default. Costs one SerpAPI credit PER STORE (6 by default). By default foreign stores are asked to deliver to Poland (shipping_location 'PL'): they list only items they ship here, with the delivery cost in `delivery`, and usually print prices already in PLN (Amazon's conversion, Polish VAT) — shipping is never included in price_pln. shipping_location 'local' compares each store as its own customers see it (NBP-converted, no delivery guarantee). Identical ASINs across stores are grouped in `asin_matches` with each store's price and the cheapest one — the reliable way to compare the exact same product. Use a precise query (brand + model) and min_price_pln to keep accessories out of a price-sorted list. Result shape: { source, fetchedAt, query, marketplaces: [{ marketplace, country, currency, status ('ok' | 'no_results' | 'error'), total_results, count, search_url, error? }], count, products: [...], asin_matches?: [{ asin, title, offers: [{ marketplace, price, currency, price_pln, url }], cheapest: { marketplace, price_pln }, spread_pln }], fx: [...], note } — the list key is `products`; each product is { marketplace, position, asin, title, brand?, url, image?, price, price_text, currency, price_pln, old_price?, discount_percent?, rating, reviews, bought_last_month?, prime?, sponsored, delivery?, stock? }. A store that fails or finds nothing is reported in `marketplaces`, not as an error.

Parameters:
- `query` (string, required): Search query, ideally brand + model, e.g. 'sony wh-1000xm5'.
- `marketplaces` (array): Stores to compare, codes or domains (pl, de, fr, it, es, nl, be, se, uk, tr, us, ca, mx, br, au, jp, in, cn, sg, ae, sa, eg). Default pl, de, fr, it, es, nl; at most 10 — one SerpAPI credit each.
- `order_by` (string): Order of the merged list: price_pln (default, cheapest first, unpriced last), relevance (the stores' own rankings interleaved) or rating. One of: price_pln, relevance, rating.
- `sort` (string): Sort sent to every store. Amazon's sort: relevance (default, Amazon's 'Featured'), price_asc, price_desc, rating (avg. customer review), newest, bestsellers. The price sorts are re-applied to the returned page by displayed price (Amazon sorts by its offer prices), with products that show no price listed last. One of: relevance, price_asc, price_desc, rating, newest, bestsellers.
- `min_price_pln` (number): Lowest price in PLN: sent to each store in its currency (NBP rate, 10% slack) and enforced exactly on price_pln.
- `max_price_pln` (number): Highest price in PLN, applied like min_price_pln.
- `brand` (string): One brand name, e.g. 'Sony' (Amazon's brand filter on every store).
- `min_rating` (number): Keep products rated at least this (0–5).
- `min_reviews` (integer): Keep products with at least this many ratings.
- `include_sponsored` (boolean): Keep sponsored slots. Default false.
- `exclude_autocorrected` (boolean): Drop results from an auto-corrected spelling of the query. Default false.
- `shipping_location` (string): Deliver-to country for the foreign stores. Default 'PL'; 'local' = each store's own country (prices in its currency and VAT, delivery to Poland unchecked).
- `delivery_zip` (string): Delivery postal code within shipping_location's country (or the store's), e.g. '00-001'.
- `limit_per_marketplace` (integer): Max products kept per store. Default 10.
- `limit` (integer): Max products in the merged list. Default 40.
- `match_asin` (boolean): Group the same ASIN found on 2+ stores into asin_matches. Default true.
- `no_cache` (boolean): Force a fresh SerpAPI fetch, bypassing this server's 5-minute result cache. Default false.

### amazon_product

Full details of one Amazon product by ASIN (or product URL — its store is used unless marketplace says otherwise) via SerpAPI's amazon_product engine; one credit, ~10–25 s. Returns every offer with PLN prices — the main price, each purchase option (new/used/…), other sellers — and the cheapest new one, plus variants (each with its own ASIN), rating histogram, specifications, bullet points, category path and a few top reviews. The same ASIN can be looked up on another store (ASINs are mostly shared across EU stores). Result shape: { source, fetchedAt, query, marketplace, asin, title, brand?, url, categories?, images?, rating, reviews, rating_histogram?: { '5': pct, … }, reviews_summary?, bought_last_month?, price, price_text, currency, price_pln, max_price?, old_price?, discount_percent?, coupons?, promotions?, delivery?, stock?, purchase_options?: [{ type, price, currency, price_pln, stock?, delivery?, features? }], other_sellers?: [{ sold_by, ship_from, price, currency, price_pln, delivery?, seller_rating?, seller_reviews?, seller_feedback? }], cheapest_offer?: { source, seller?, price_pln }, variants?: [{ dimension, options: [{ asin, name, selected? }] }], about_item?, specifications?, details?, top_reviews?, fx, note? }.

Parameters:
- `asin` (string, required): ASIN (10 characters, e.g. 'B09Y2MYL5C', from an amazon_search result) or an Amazon product URL containing /dp/<ASIN>.
- `marketplace` (string): Amazon store: its code (pl, de, fr, it, es, nl, be, se, uk, tr, us, ca, mx, br, au, jp, in, cn, sg, ae, sa, eg) or domain (amazon.de, amazon.co.uk…). Default pl. Overrides a URL's own store — to look the ASIN up elsewhere.
- `language` (string): Store language as <language>_<REGION>, e.g. 'en_GB' for English titles on amazon.de. Default: the store's own (de_DE on amazon.de) — each store only offers a few (amazon_marketplaces lists them).
- `shipping_location` (string): Deliver-to country as an ISO code, e.g. 'PL': a foreign store then lists only items it delivers there, adds delivery cost to `delivery`, and usually prints prices already converted to PLN by Amazon (VAT of the destination). 'local' (or omitted) = the store's own country.
- `delivery_zip` (string): Delivery postal code within shipping_location's country (or the store's), e.g. '00-001'.
- `other_sellers` (boolean): Include the other sellers' offers. Default true.
- `include_reviews` (boolean): Include up to 3 top reviews (600 chars each). Default true.
- `convert_to_pln` (boolean): Add price_pln at the NBP mid rate. Default true.
- `no_cache` (boolean): Force a fresh SerpAPI fetch, bypassing this server's 5-minute result cache. Default false.

### amazon_marketplaces

List the 22 Amazon stores the other amazon_* tools support — code, domain, country, currency, the NBP table its currency converts with, default and available languages, and whether it is in the EU (no customs to Poland). Static and free: call it to pick marketplaces without guessing.

Parameters: none

## Deweloperuch MCP

Endpoint: https://mcp.wondel.ai/deweloperuch/mcp
Polish flat prices from deweloperuch.pl: RCN transaction prices (valuation, city statistics, rankings, buildings) and developers' asking prices.
Latency: ~1–5 s, direct fetch of deweloperuch.pl's JSON API, at most one request in flight and one per second per isolate — per isolate, not global (a call makes 1–2 requests, each waiting its turn for up to 20 s); results cached 1–24 h; Warsaw's offer dump is 1.3 MB; stops on a block (401/403/429/challenge)
Docs: https://mcps.wondel.ai/servers/deweloperuch/
Source: Deweloperuch.pl (RCN price register data and developer price lists) (https://deweloperuch.pl)

### deweloperuch_search_locations

Find cities, districts and streets in Poland by a fragment of the name. Use it first, to turn a place name into the city_slug the other deweloperuch_* tools take (and the lat/lng of a street or district for deweloperuch_estimate_property_value — an approximate point, not a particular building). Returns no prices. A locality with offer_count 0 has no developer offers. Costs two requests to deweloperuch.pl. deweloperuch.pl is a free community project queried politely (one request at a time, results cached): if a result is an error starting with STOP, stop using the deweloperuch_* tools, retry nothing, look for no workaround and tell the user that market data is temporarily unavailable. Result shape: { total: number | null, returned, truncated, hint?, items: [{ kind: 'city' | 'district' | 'street', name, city, city_slug, district?, street?, lat?, lng?, offer_count? }] } — the list key is `items`. `total` is null when more match than shown (truncated=true: refine the name). `offer_count` is the site's count of developer offers (exact for districts, approximate for streets and cities). A district or street carries the city_slug of its city (this server's tools have no district filter). Nothing matching is not an error: returned=0 with a hint.

Parameters:
- `query` (string, required): Fragment of a city, district or street name, 2–100 characters, Polish characters allowed, e.g. Kraków, Mokotów.

### deweloperuch_estimate_property_value

Estimate the value of a flat of a given area at a point (lat, lng) in Poland from nearby transaction prices of the Real Estate Price Register (RCN), via deweloperuch.pl. The result is approximate: a comparison with nearby sales, not a professional appraisal. Use it when the user asks what a flat may be worth or whether its price is market. Needs coordinates — it does not geocode an address: take them from the user, from deweloperuch_search_locations (a street or district: an approximate point) or from the user's own data. Every call is a request to the site: do not value many points in a series. Two kinds of prices must not be mixed: developers' asking prices (deweloperuch_search_investments, deweloperuch_get_investment, deweloperuch_get_offer, deweloperuch_get_market_statistics), RCN transaction prices (deweloperuch_estimate_property_value, deweloperuch_get_transaction_statistics, deweloperuch_rank_locations, deweloperuch_get_building) — what flats actually sold for, from the Real Estate Price Register. deweloperuch.pl is a free community project queried politely (one request at a time, results cached): if a result is an error starting with STOP, stop using the deweloperuch_* tools, retry nothing, look for no workaround and tell the user that market data is temporarily unavailable. Result shape: { lat, lng, area_m2, estimated_value (PLN, or null when the site gave no estimate — read the hint), low_confidence? (true when fewer than 5 comparable transactions: quote the estimate only as indicative, with the caveat from hint), price_per_m2?, radius_m?, period_months? (where and how long ago the comparables are from), stats?: { count, median_price_per_m2, average_price_per_m2, min_price_per_m2, max_price_per_m2 }, comparables_total, comparables_returned, comparables_omitted, truncated, hint?, source, comparables: [{ address?, date?, price, area_m2, price_per_m2, floor?, distance_m (rounded by the site to 50 m), market ('primary' | 'secondary'), building_slug? (for deweloperuch_get_building) }] } — the list key is `comparables`, the nearest first, at most `limit` of them (0 = only the estimate and stats). Do not assume estimated_value = price_per_m2 × area_m2: the site may ignore a fractional area.

Parameters:
- `lat` (number, required): Latitude of the point in Poland in degrees, e.g. 52.2297 (lat of a street or district from deweloperuch_search_locations, not just a city).
- `lng` (number, required): Longitude of the point in Poland in degrees, e.g. 21.0122.
- `area_m2` (number, required): Area of the flat in m², 10–500, e.g. 48.5.
- `address` (string): Optional address text, 3–200 characters, e.g. Marszałkowska 100, Warszawa. Sent to the site but it does not set the location: lat and lng do.
- `limit` (integer): How many nearest comparable transactions to return, 0–50. Default 10 (about 210 characters each); 0 = only the estimate and stats.

### deweloperuch_get_transaction_statistics

Transaction prices of flats in one city from the Real Estate Price Register (RCN), month by month or quarter by quarter: the number of transactions and the prices per m². These are prices flats actually sold for, not developers' asking prices. granularity=month (default): median and mean price per m², median area and median flat price. granularity=quarter: only the mean price per m² and the count, but a longer history. Months and quarters are different statistics: do not join them in one chart or series. Limits: flats only and whole cities only (city_slug from deweloperuch_search_locations; no districts, streets or whole Poland). Default: the latest 12 periods; truncated=true means older ones exist (raise periods, at most 60). The newest periods are incomplete (the RCN lags by months): skip a period with incomplete=true — do not quote its prices as a trend — and end a trend at last_complete_period (even its data may still change). Two kinds of prices must not be mixed: developers' asking prices (deweloperuch_search_investments, deweloperuch_get_investment, deweloperuch_get_offer, deweloperuch_get_market_statistics), RCN transaction prices (deweloperuch_estimate_property_value, deweloperuch_get_transaction_statistics, deweloperuch_rank_locations, deweloperuch_get_building) — what flats actually sold for, from the Real Estate Price Register. deweloperuch.pl is a free community project queried politely (one request at a time, results cached): if a result is an error starting with STOP, stop using the deweloperuch_* tools, retry nothing, look for no workaround and tell the user that market data is temporarily unavailable. Fields ending in _url are pages of deweloperuch.pl: give them to the user as links. Result shape: { city_slug, granularity, total, returned, truncated, available_from, last_complete_period?, hint?, note, stats_url, source, periods: [{ period ('2025-08' | '2025-Q3'), transactions, incomplete? (only when true), median_price_per_m2?, average_price_per_m2?, median_area_m2?, median_price? }] } — the list key is `periods`, oldest first; a period without transactions has no prices. last_complete_period is omitted when the history is too short or has too few transactions to judge; then read hint. Read `note` before describing a trend.

Parameters:
- `city` (string, required): city_slug of a city from deweloperuch_search_locations, e.g. warszawa, krakow, gdansk (lowercase, no Polish characters). Whole cities only: not districts, streets or polska.
- `granularity` (string): month (default): months with median and mean price per m², median area and median price; quarter: quarters with only the mean price per m² and the count, but a longer history. One of: month, quarter.
- `periods` (integer): How many latest periods (months or quarters) to return, 1–60. Default 12. 60 months is about 9,000 characters; for a multi-year trend choose quarter.

### deweloperuch_rank_locations

A ranking of localities (level=city) or powiats (level=powiat) in Poland by Real Estate Price Register (RCN) transactions: the number of transactions and the transaction price per m². Use it to compare many cities; for the trend of one city over time use deweloperuch_get_transaction_statistics. These are transaction prices, not asking prices. Limits: the site gives no period and does not say whether prices and areas are means or medians — present them as the values the site gives. Powiat transaction counts cover many years: they only order the list, are not the current volume and must not be compared with locality counts. Sorting by price leaves out places with fewer than 20 transactions by default (a price from a handful of sales is chance); min_transactions=0 shows all places, 50 gives steadier prices. Two kinds of prices must not be mixed: developers' asking prices (deweloperuch_search_investments, deweloperuch_get_investment, deweloperuch_get_offer, deweloperuch_get_market_statistics), RCN transaction prices (deweloperuch_estimate_property_value, deweloperuch_get_transaction_statistics, deweloperuch_rank_locations, deweloperuch_get_building) — what flats actually sold for, from the Real Estate Price Register. deweloperuch.pl is a free community project queried politely (one request at a time, results cached): if a result is an error starting with STOP, stop using the deweloperuch_* tools, retry nothing, look for no workaround and tell the user that market data is temporarily unavailable. Fields ending in _url are pages of deweloperuch.pl: give them to the user as links. Result shape: { level, sort, min_transactions (the threshold applied), total (places with at least that many transactions), returned, truncated, hint?, ranking_url? (city level), source, items: [{ name, city_slug? (city) | powiat_id? (informational: no tool takes it), transaction_count, price_per_m2?, area_m2?, price? }] } — the list key is `items`. A place without a price has no price fields and sorts last by price.

Parameters:
- `level` (string): city (default): localities — cities, small towns and villages; powiat: powiats (no ranking_url and no counterpart in deweloperuch_search_locations). One of: city, powiat.
- `sort` (string): transactions_desc (default): most transactions; price_per_m2_desc: highest price per m²; price_per_m2_asc: lowest price per m². Places without a price come last. One of: transactions_desc, price_per_m2_desc, price_per_m2_asc.
- `limit` (integer): How many top entries of the ranking to return, 1–100. Default 20 (about 120 characters each). To see more places narrow min_transactions rather than raising the limit.
- `min_transactions` (integer): Fewest transactions a place needs to be ranked. Omitted = the default threshold: 20 when sorting by price, 0 for transactions_desc. 0 = all places; e.g. 50 gives steadier prices.

### deweloperuch_get_building

A building of the Real Estate Price Register (RCN): address, coordinates, the site's average prices and the flats sold in it with the date, price, price per m², market, kind and parties of each transaction. These are the prices the flats sold for, not developers' asking prices. building_slug is the last part of the address of the building's page with transaction prices on deweloperuch.pl, e.g. 23-marca-79c-sopot — comparables of deweloperuch_estimate_property_value carry one in building_slug; when you have none, ask the user for the link of that page. building_url is that page. Order: the unit with the newest transaction first, each unit's transactions oldest first. Do not average transactions whose classification is not 'regular' (share, enforcement, discount…) with regular sales: they are not ordinary sales at a market price; non_regular_transactions counts them. Limits: buildings with flats only, not houses. Returns at most `limit` units (default 10); truncated and units_omitted say whether and how many were left out, units_total and transactions_total count the whole building. The newest months are often incomplete (the register lags). include_trend=true adds the mean price per m² of transactions around the building (radius radius_km) in the latest 12 quarters — one more request. Buyers and sellers appear only as a type, never by name. Two kinds of prices must not be mixed: developers' asking prices (deweloperuch_search_investments, deweloperuch_get_investment, deweloperuch_get_offer, deweloperuch_get_market_statistics), RCN transaction prices (deweloperuch_estimate_property_value, deweloperuch_get_transaction_statistics, deweloperuch_rank_locations, deweloperuch_get_building) — what flats actually sold for, from the Real Estate Price Register. deweloperuch.pl is a free community project queried politely (one request at a time, results cached): if a result is an error starting with STOP, stop using the deweloperuch_* tools, retry nothing, look for no workaround and tell the user that market data is temporarily unavailable. Fields ending in _url are pages of deweloperuch.pl: give them to the user as links. Result shape: { building_slug, name? (the address as the register writes it; absent when it gives none — the place is then in city), building_url, city, city_slug, street?, lat, lng, avg_price?, avg_area_m2?, avg_price_per_m2? (the site's averages; a value of 0 or less is omitted), first_transaction_date, last_transaction_date, units_total, transactions_total, non_regular_transactions? (e.g. { share: 1 }), units: [{ floor?, rooms?, area_m2, transactions: [{ date, price, price_per_m2, currency? (absent = PLN), market ('primary' | 'secondary'), classification ('regular' | 'share' | 'bulk' | 'government' | 'enforcement' | 'discount' | 'anomaly_low' | 'anomaly_high'), buyer, seller ('natural_person' | 'legal_person'), share? (only when a share was sold) }] }], units_returned, units_omitted, truncated, hint?, neighbourhood_trend?: { radius_km?, total, returned, truncated, quarters: [{ period, avg_price_per_m2?, transactions? }] }, source } — the list key is `units`.

Parameters:
- `building_slug` (string, required): Building slug, e.g. 23-marca-79c-sopot: lowercase letters without Polish characters, digits and hyphens, from the building's page address or from comparables in deweloperuch_estimate_property_value.
- `limit` (integer): Most units in the result (those with the newest transactions), default 10, at most 50; 0 = only the building summary. About 200 characters per transaction.
- `include_trend` (boolean): true: add the mean price per m² of transactions around the building in the latest 12 quarters (one more request). Default false.

### deweloperuch_get_market_statistics

Statistics of the developers' offer market in one city: the number of offers, investments and developers, the distribution of prices (PLN), prices per m² (PLN/m²) and areas (m²) as min, p25, median, p75 and max, and the largest developers by number of offers (developer_slug, offers, investments, median_price_per_m2, developer_url; developer_slug is an identifier — the developer's name is not part of the result). Optionally only offers within a price and area range. Use it when the question is about a city's market (typical prices, who has the most offers), not about particular flats. Limits: active offers only (no archived) and one city only (city_slug from deweloperuch_search_locations; polska does not work). The figures are computed here from the site's compact list of the city's active offers (the list itself never leaves; Warsaw's is 1.3 MB, so a call can take a few seconds) and can differ slightly from the site's own offer totals. These are developers' asking prices, not transaction prices. Two kinds of prices must not be mixed: developers' asking prices (deweloperuch_search_investments, deweloperuch_get_investment, deweloperuch_get_offer, deweloperuch_get_market_statistics), RCN transaction prices (deweloperuch_estimate_property_value, deweloperuch_get_transaction_statistics, deweloperuch_rank_locations, deweloperuch_get_building) — what flats actually sold for, from the Real Estate Price Register. deweloperuch.pl is a free community project queried politely (one request at a time, results cached): if a result is an error starting with STOP, stop using the deweloperuch_* tools, retry nothing, look for no workaround and tell the user that market data is temporarily unavailable. Fields ending in _url are pages of deweloperuch.pl: give them to the user as links. Result shape: { city_slug, offers (matching active offers), investments, developers, price?, price_per_m2?, area_m2? (each { min, p25, median, p75, max }), top_developers: [{ developer_slug, offers, investments, median_price_per_m2?, developer_url? }], developers_returned, developers_omitted, truncated, hint? (also explains an empty result), list_url? (the same offers on deweloperuch.pl), source } — the list key is `top_developers`.

Parameters:
- `city` (string, required): city_slug of one city from deweloperuch_search_locations, e.g. krakow (not polska).
- `price_min` (integer): Lowest offer price in PLN.
- `price_max` (integer): Highest offer price in PLN.
- `area_min` (integer): Smallest area in m².
- `area_max` (integer): Largest area in m².
- `top_developers` (integer): How many of the largest developers to show, 1–30. Default 10.

### deweloperuch_search_investments

Search investments (developer projects, primary market). Two modes: with city (full data) or with name alone (whole Poland; only investment_slug, name and offers_active, in the site's order). Use it when the question is about projects rather than single flats: e.g. the cheapest per m² in a city, the investments of one developer (city + developer_slug from deweloperuch_search_developers), the slug of an investment by its name. With city it returns the investments the site shows on the city's map (those with active offers; ones without may be missing) with averages over active offers; name and developer_slug narrow the list, sort orders it (default: most active offers; entries without an average come last). Offers and details of one investment come from deweloperuch_get_investment (investment_slug); a particular offer's price history from deweloperuch_get_offer. No price or area filter here — for those ranges use deweloperuch_get_market_statistics. city=polska does not work. These are developers' asking prices. Two kinds of prices must not be mixed: developers' asking prices (deweloperuch_search_investments, deweloperuch_get_investment, deweloperuch_get_offer, deweloperuch_get_market_statistics), RCN transaction prices (deweloperuch_estimate_property_value, deweloperuch_get_transaction_statistics, deweloperuch_rank_locations, deweloperuch_get_building) — what flats actually sold for, from the Real Estate Price Register. deweloperuch.pl is a free community project queried politely (one request at a time, results cached): if a result is an error starting with STOP, stop using the deweloperuch_* tools, retry nothing, look for no workaround and tell the user that market data is temporarily unavailable. Fields ending in _url are pages of deweloperuch.pl: give them to the user as links. Result shape: { total: number | null (null when the site does not say — a search by name), returned, truncated, hint?, source, items: [with city: { investment_slug, name, city_slug?, district?, street?, status? ('active' | 'archived'), offers_active?, offers_total?, avg_price?, avg_area_m2?, avg_price_per_m2? (active offers only, as the site counts them), developer_slug?, developer_name?, investment_url?, developer_url? } | by name: { investment_slug, name, offers_active? }] } — the list key is `items`.

Parameters:
- `city` (string): city_slug of one city from deweloperuch_search_locations, e.g. warszawa, sopot (not polska).
- `name` (string): Fragment of an investment name, 2–100 characters, e.g. Kolibki. With city, case and Polish characters do not matter; without city the site searches the whole country.
- `developer_slug` (string): developer_slug from deweloperuch_search_developers or from results of the investment tools, e.g. atal. Only with city.
- `sort` (string): Only with city. active_offers (default): most active offers; price_per_m2_asc / price_per_m2_desc: average price per m²; price_asc / price_desc: average price; name: alphabetical. Entries without an average come last. One of: active_offers, price_per_m2_asc, price_per_m2_desc, price_asc, price_desc, name.
- `limit` (integer): Most investments in the result, 1–30, default 10 (about 550–750 characters each with links).

### deweloperuch_get_investment

An investment (developer project): city, street, coordinates, developer, the average prices of active offers, the number of offers and the list of offers (active first, then archived). Use it to see the flats of one project. investment_slug comes from deweloperuch_search_investments. investment_url and developer_url are the investment's and developer's pages on deweloperuch.pl: give them to the user as links. Limits: returns at most `limit` offers (default 20); offers_returned, truncated and offers_omitted say what was left out — offers_total is the site's count (also archived). With a large investment do not raise the limit without need. include_history=true adds the price history of every returned offer: the result is longer and takes one more request. For a single offer use deweloperuch_get_offer. These are developers' asking prices. Two kinds of prices must not be mixed: developers' asking prices (deweloperuch_search_investments, deweloperuch_get_investment, deweloperuch_get_offer, deweloperuch_get_market_statistics), RCN transaction prices (deweloperuch_estimate_property_value, deweloperuch_get_transaction_statistics, deweloperuch_rank_locations, deweloperuch_get_building) — what flats actually sold for, from the Real Estate Price Register. deweloperuch.pl is a free community project queried politely (one request at a time, results cached): if a result is an error starting with STOP, stop using the deweloperuch_* tools, retry nothing, look for no workaround and tell the user that market data is temporarily unavailable. Result shape: { investment_slug, name, status ('active' | 'archived'), investment_url?, city, city_slug, street?, lat?, lng?, currency?, developer: { developer_slug, name, website?, description? }, developer_url?, avg_price?, avg_area_m2?, avg_price_per_m2? (active offers, PLN), offers_active?, offers_total?, offers: [{ offer_id, name, status, price?, currency?, area_m2?, price_per_m2?, price_change_since_start? (PLN; negative = cheaper), price_change_since_start_pct?, creation_date?, last_event_date?, last_change_date?, price_history?: [{ date?, kind ('offer' | 'archived' | 'restored'), price? }] }], offers_returned, offers_omitted, truncated, source } — the list key is `offers`; `kind: offer` is every asking-price entry of the history, the first price and each change.

Parameters:
- `investment_slug` (string, required): investment_slug from deweloperuch_search_investments, e.g. smolna.
- `include_history` (boolean): true: add the price history of every returned offer (a longer result, one more request). Default false.
- `limit` (integer): Most offers in the result (active first), 0–200, default 20; 0 = only the investment summary. About 300 characters per offer, a few hundred more with the price history.

### deweloperuch_get_offer

One offer with its full price history, investment and developer. Use it to see how a flat's asking price changed. Needs offer_id and investment_slug (both come from deweloperuch_get_investment; investment_slug also from deweloperuch_search_investments): offer_id alone is not enough. investment_url and developer_url are the investment's and developer's pages on deweloperuch.pl: give them to the user as links. price_flags (as of today; prices from `offer` and `restored` events, a withdrawal ends the price in effect; an archived offer is judged up to the day it was withdrawn): lowest_price_30d and lowest_price_90d are the lowest price in effect over the last 30 and 90 days, including one set before the window; price_changes is the number of price changes; largest_drop_pct and largest_rise_pct are the largest single drop and rise as a % of the previous price; suspicious_reduction=true when the latest drop came within 30 days after a rise and the new price is not below the lowest of the 30 days before it (a 'promotion' after a price increase). These are developers' asking prices, not transaction prices. Two kinds of prices must not be mixed: developers' asking prices (deweloperuch_search_investments, deweloperuch_get_investment, deweloperuch_get_offer, deweloperuch_get_market_statistics), RCN transaction prices (deweloperuch_estimate_property_value, deweloperuch_get_transaction_statistics, deweloperuch_rank_locations, deweloperuch_get_building) — what flats actually sold for, from the Real Estate Price Register. deweloperuch.pl is a free community project queried politely (one request at a time, results cached): if a result is an error starting with STOP, stop using the deweloperuch_* tools, retry nothing, look for no workaround and tell the user that market data is temporarily unavailable. Result shape: { offer_id, name, status ('active' | 'archived'), price? (PLN, asking), currency?, area_m2?, price_per_m2?, price_change_since_start? (PLN; negative = cheaper), price_change_since_start_pct?, creation_date?, last_event_date?, last_change_date?, investment_slug, investment_name, investment_url?, city, city_slug, developer: { developer_slug, name, website?, description? }, developer_url?, price_history: [{ date?, kind ('offer' | 'archived' | 'restored'), price? }], price_flags: { lowest_price_30d?, lowest_price_90d?, price_changes, largest_drop_pct?, largest_rise_pct?, suspicious_reduction }, source } — the list key is `price_history`, oldest first. A flag with no basis (no drop yet) is omitted.

Parameters:
- `offer_id` (integer, required): offer_id from deweloperuch_get_investment.
- `investment_slug` (string, required): investment_slug of this offer's investment, e.g. smolna (from deweloperuch_search_investments or deweloperuch_get_investment).

### deweloperuch_search_developers

Find developers (primary market) by a fragment of the name, e.g. atal or dom development. Use it to turn a developer's name into the developer_slug that deweloperuch_search_investments takes (with city) to list that developer's investments. Returns no offers or prices. truncated=true means more developers match than shown: refine the name or raise limit (at most 20); total is null when it is only known that there are more. deweloperuch.pl is a free community project queried politely (one request at a time, results cached): if a result is an error starting with STOP, stop using the deweloperuch_* tools, retry nothing, look for no workaround and tell the user that market data is temporarily unavailable. Fields ending in _url are pages of deweloperuch.pl: give them to the user as links. Result shape: { total: number | null, returned, truncated, hint?, items: [{ developer_slug, name, offer_count? (the site's count of the developer's offers across Poland), developer_url? }] } — the list key is `items`. developer_url is the developer's profile for the whole of Poland on deweloperuch.pl.

Parameters:
- `name` (string, required): Fragment of a developer name, 2–100 characters, e.g. atal, Dom Development.
- `limit` (integer): Most developers in the result, 1–20, default 5 (about 150 characters each).