Ristorante Nautico Bardolino APIristorantenauticobardolino.com ↗
Get the full Ristorante Nautico Bardolino menu as structured JSON: all sections, dish names, EUR prices, and German/English descriptions in one call.
What is the Ristorante Nautico Bardolino API?
The Ristorante Nautico Bardolino API exposes the restaurant's complete published menu through a single get_menu endpoint, returning up to five menu sections (Antipasti, Primi, Secondi, Contorni, Insalata) with every dish's Italian name, EUR price, and bilingual descriptions in German and English. Each response includes 6 top-level fields — sections, currency, page_title, total_dishes, has_item_prices, and structured per-dish rows — giving you a full machine-readable snapshot of the current menu in one round trip.
No input parameters required.
curl -X GET 'https://api.parse.bot/scraper/c26fb29c-e560-452d-913f-4a35b097fcba/get_menu' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace ristorantenauticobardolino-com-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Walkthrough: Ristorante Nautico Bardolino menu SDK — one call, full menu."""
from parse_apis.ristorantenauticobardolino_com_api import RistoranteNautico, ExtractionFailed
client = RistoranteNautico()
# Fetch the full current menu in a single round-trip.
try:
menu = client.menu.get()
except ExtractionFailed:
print("Menu page could not be extracted — site may have changed layout.")
raise
print(f"{menu.page_title} ({menu.currency}, {menu.total_dishes} dishes)")
# Walk every section and its dishes with typed field access.
for section in menu.sections or []:
print(f"\n== {section.title} — {section.subtitle} ==")
for dish in section.dishes:
price = f"{dish.price_eur:.2f} {menu.currency}" if dish.price_eur is not None else dish.price_text
print(f" {dish.name}: {price}")
if dish.description_en:
print(f" EN: {dish.description_en}")
print("\nexercised: menu.get / Section / Dish field access")
Fetches the restaurant's full current menu page in one round trip and returns it as an array of sections, each holding its dishes. One row per dish, with the Italian dish name, German and English descriptions (either may be null when the site omits them), the price exactly as printed (price_text), all numeric EUR amounts parsed from it (prices_eur — a dish with a size choice carries two values, e.g. a small/large salad) and the first of those as price_eur. has_item_prices is true when at least one dish carries a numeric price; at build time every dish did. total_dishes counts dishes across all sections. No parameters; the menu is a single page with no pagination. Returns an extraction failure if the page has no menu sections or no dishes.
No input parameters required.
{
"type": "object",
"fields": {
"currency": "string, ISO currency code of all prices (EUR, read from the € sign on the page)",
"sections": "array of menu sections, each with title (Italian), subtitle (German · English) and a dishes array of {name, price_text, prices_eur (array of numbers), price_eur (number or null), description_de, description_en}",
"page_title": "string, HTML title of the menu page",
"total_dishes": "integer, number of dishes across all sections",
"has_item_prices": "boolean, true when at least one dish has a numeric price"
},
"sample": {
"data": {
"currency": "EUR",
"sections": [
{
"title": "Antipasti",
"dishes": [
{
"name": "Luccio con polenta alla Gardesana",
"price_eur": 14,
"price_text": "14,00 €",
"prices_eur": [
14
],
"description_de": "Seehecht auf Gardesana Art mit Polenta.",
"description_en": "Gardesana style hake with polenta (corn flour)."
}
],
"subtitle": "Vorspeisen · Appetizers"
},
{
"title": "Insalata",
"dishes": [
{
"name": "Insalata mista",
"price_eur": 6,
"price_text": "6,00 € / 8,00 €",
"prices_eur": [
6,
8
],
"description_de": "Gemischter Salat.",
"description_en": "Mixed salad."
}
],
"subtitle": "Salate · Salad"
}
],
"page_title": "Menù – Ristorante Nautico Bardolino",
"total_dishes": 21,
"has_item_prices": true
},
"status": "success"
}
}About the Ristorante Nautico Bardolino API
What get_menu Returns
The single get_menu endpoint takes no input parameters and returns the restaurant's full menu page as structured JSON. The top-level response carries a page_title string (the HTML title of the menu page), a currency field confirming EUR, a total_dishes integer counting every dish across all sections, and a has_item_prices boolean that is true when at least one dish carries a numeric price.
Section and Dish Structure
The core payload is the sections array. Each element has a title (the Italian section heading, e.g. "Antipasti" or "Secondi"), a subtitle combining the German and English translations of that heading, and a dishes array. Each dish object contains name (Italian), price_text (the price exactly as printed on the menu), prices_eur (the numeric EUR value), and both German and English description strings — either of which may be null when the site omits a translation for that dish.
Coverage and Freshness
The endpoint reflects what is currently published on the restaurant's menu page. All five standard Italian course sections are represented when present. Prices are expressed in EUR, matching the € symbol on the source page. There is no filtering or pagination — the endpoint always returns the full menu in a single response, making it straightforward to diff against a cached version to detect menu changes.
The Ristorante Nautico Bardolino API is a managed, monitored endpoint for ristorantenauticobardolino.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when ristorantenauticobardolino.com changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official ristorantenauticobardolino.com API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Build a menu display widget for a Lago di Garda travel guide that shows current dishes and prices.
- Monitor EUR price changes across menu sections and alert when
price_textvalues shift. - Populate a restaurant comparison app with structured dish data using
nameandprices_eur. - Generate translated menu cards by consuming the German and English description fields.
- Feed a chatbot that answers questions about available courses using section
titleanddishesarrays. - Archive periodic snapshots of the menu to track seasonal dish additions via
total_dishes.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 200 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
| Team | $300/mo | 20,000 | 300 req/min |
| Company | $1,000/mo | 100,000 | 500 req/min |
Each endpoint has a fixed posted price per successful call — most fall between 1 and 10 credits — shown on this API's page before you run it. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does Ristorante Nautico Bardolino have an official developer API?+
What does the `get_menu` endpoint return for dishes that have no description?+
null for any dish where the site omits those translations. The name and price_text fields are always populated when the dish appears in the menu.Can I retrieve a single menu section, such as only Antipasti, without fetching the full menu?+
get_menu always returns all sections in one response. You can filter the sections array client-side by matching the title field. If section-level filtering on the API side is important, you can fork it on Parse and revise it to add a section query parameter.Does the API expose wine list, daily specials, or drink menu items?+
How should I detect whether prices are actually present in a response?+
has_item_prices boolean at the top level. It is true when at least one dish in the response carries a numeric value in prices_eur. You can also inspect individual dish objects — prices_eur will be null for any dish listed without a price.