Discover/Osteria Peschieradelgarda API
live

Osteria Peschieradelgarda APIosteria-peschieradelgarda.it ↗

Access structured food and dessert menus from L'Osteria Peschiera del Garda: dish names, EUR prices, multilingual descriptions, cover charge, and per-section price stats.

Endpoint health
verified 2h ago
get_menu
1/1 passing latest checkself-healing
Endpoints
1
Updated
3h ago

What is the Osteria Peschieradelgarda API?

The osteria-peschieradelgarda.it API exposes one endpoint — get_menu — that returns the full published menu of L'Osteria in Peschiera del Garda as structured data with over 10 response fields, including dish names in Italian, prices in EUR, multilingual description lines, section-level price summaries, the per-person cover charge, and the document edition stamp. Both the food menu and the desserts menu are accessible by passing the optional menu parameter.

This call costs5 credits / call— charged only on success
Try it
Which published menu to return.
→ api.parse.bot/scraper/4af4fb00-f3be-4e7c-b5cf-855884bf8930/<endpoint>
Ready to send
Fill in the parameters and hit sign in to send to see live response data here.
Call it over HTTPgrab a free API key at signup
curl -X GET 'https://api.parse.bot/scraper/4af4fb00-f3be-4e7c-b5cf-855884bf8930/get_menu?menu=food' \
  -H 'X-API-Key: $PARSE_API_KEY'
All endpoints · 1 totalmissing one? ·

Returns the restaurant's currently published menu as structured sections (e.g. antipasti, primi/pasta, secondi, specialities, side dishes, children's menu, pizzas) with one item per dish: Italian name, price in EUR, and the printed description lines (ingredients and/or German and English translations, in print order). The food menu also carries the per-person cover charge (cover_charge) and each section plus the whole menu carries a price_summary (count, min, max, average of item prices) that can be used as a per-person price range; these summaries are computed from the extracted prices. The menu selector chooses the published food menu or the dessert/after-dinner menu; the dessert menu's first section carries no printed heading (name null) and also lists dessert wines and grappas. Prices are the published list prices without service. One call fetches the whole menu; there is no pagination. document_name identifies the published menu edition (it changes when the restaurant replaces the menu). The wine list is not covered.

Input
ParamTypeDescription
menustringWhich published menu to return.
Response
{
  "type": "object",
  "fields": {
    "menu": "the menu selector echoed (food or desserts)",
    "notes": "printed remarks that precede the first section",
    "currency": "ISO currency of all prices (EUR)",
    "sections": "array of menu sections in print order: name (null when unlabelled), subtitle (translated heading), items, notes (printed section remarks), price_summary",
    "cover_charge": "object {label, price_eur} with the per-person cover charge printed on the food menu; null when the menu prints none (desserts)",
    "document_name": "name of the published menu edition, e.g. month/year stamped",
    "price_summary": "object {count, min_eur, max_eur, avg_eur} over all priced items of the menu",
    "sections[].items": "array of dishes: name (Italian), price_eur (number, null if unpriced), descriptions (array of printed description/translation lines)",
    "sections[].price_summary": "object {count, min_eur, max_eur, avg_eur} over the section's priced items; min/max/avg null when count is 0"
  },
  "sample": {
    "data": {
      "menu": "food",
      "notes": [],
      "currency": "EUR",
      "sections": [
        {
          "name": "I PRIMI PIATTI",
          "items": [
            {
              "name": "CASERECCE AL RAGÙ D’ANATRA",
              "price_eur": 14,
              "descriptions": [
                "Caserecce Nudeln mit Entensauce",
                "Caserecce pasta with duck sauce"
              ]
            },
            {
              "name": "BIGOLI CACIO E PEPE",
              "price_eur": 14,
              "descriptions": [
                "Bigoli mit Käse und Pfeffer",
                "Bigoli with cheese and pepper"
              ]
            }
          ],
          "notes": [],
          "subtitle": "ERSTE GERICHTE - FIRST COURSE",
          "price_summary": {
            "count": 8,
            "avg_eur": 15,
            "max_eur": 17,
            "min_eur": 14
          }
        },
        {
          "name": "LE PIZZE",
          "items": [
            {
              "name": "MARGHERITA",
              "price_eur": 7,
              "descriptions": [
                "Pomodoro, mozzarella, basilico",
                "Tomaten, Mozzarella, Basilikum",
                "Tomatoes, cheese, basil"
              ]
            }
          ],
          "notes": [
            "PER LE NOSTRE PIZZE UTILIZZIAMO SOLO FARINE NATURALI MACINATE A PIETRA CON GRANO",
            "PROVENIENTE DA COLTURE BIOLOGICHE, CHE LE RENDE UNICHE PER DIGERIBILITÀ E SAPORE."
          ],
          "subtitle": "UNSERE PIZZAS - OUR PIZZAS",
          "price_summary": {
            "count": 15,
            "avg_eur": 9.9,
            "max_eur": 15,
            "min_eur": 7
          }
        }
      ],
      "cover_charge": {
        "label": "Coperto - Gedeck - Cover charge",
        "price_eur": 2.5
      },
      "document_name": "menu OSTERIA 07_2026",
      "price_summary": {
        "count": 55,
        "avg_eur": 12.21,
        "max_eur": 25,
        "min_eur": 5
      }
    },
    "status": "success"
  }
}

About the Osteria Peschieradelgarda API

What get_menu Returns

Calling get_menu returns the restaurant's currently published menu as an ordered array of sections — covering categories such as antipasti, primi/pasta, secondi, specialities, side dishes, children's menu, and pizzas. Each section carries a name, an optional subtitle (translated heading), a notes field for printed section remarks, and a price_summary object with count, min_eur, max_eur, and avg_eur across priced items in that section.

Dish-Level Fields

Within each section, items is an array of individual dishes. Every item exposes its Italian name, a price_eur value (a number, or null for unpriced items), and a descriptions array holding the printed lines — typically ingredient detail and German or English translations as they appear on the printed menu. This makes the response usable for multilingual display without further translation work.

Menu Selector and Document Metadata

The optional menu input accepts food or desserts to select which published menu to retrieve. The response echoes the selector back in the menu field. A document_name field carries the edition label (e.g., a month/year stamp) so callers can detect when the menu has been updated. Top-level notes capture any printed remarks that appear before the first section. The cover_charge object — {label, price_eur} — is present on the food menu and null on the desserts menu.

Price Summary

Beyond individual item prices, the response includes a top-level price_summary aggregating count, min_eur, max_eur, and avg_eur across all priced items in the selected menu. This makes it straightforward to display price-range context or run comparisons without iterating every item manually.

Reliability & maintenanceVerified

The Osteria Peschieradelgarda API is a managed, monitored endpoint for osteria-peschieradelgarda.it — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when osteria-peschieradelgarda.it 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 osteria-peschieradelgarda.it 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.

Last verified
2h ago
Latest check
1/1 endpoint passing
Maintenance
Monitored & self-healing
Will this API break when the source site changes?+
It's built not to. Every endpoint is health-checked on a schedule with automated test probes. When the source site changes and a check fails, the API is automatically queued for repair and re-verified — that's the self-healing layer. Each API page shows when its endpoints were last verified. And because marketplace APIs are shared, any fix reaches everyone using it.
Is this an official API from the source site?+
No — Parse APIs are independent, managed REST wrappers over publicly available data. That is the point: where a site has no official API (or only a limited one), Parse gives you a maintained, monitored endpoint for that data and keeps it working as the site changes — so you get a stable contract over a source that never promised one.
Can I fix or extend this API myself if I need a new endpoint or field?+
Yes — and you don't have to wait on us. This API was generated by the Parse agent, which stays attached. Describe the change in plain English ("add an endpoint that returns reviews", "fix the price field") in the revise box on the API page or via the revise_api MCP tool, and the agent rebuilds it against the live site in minutes. Contributing the change back to the public API is free.
What happens if I call an endpoint that has an issue?+
Errors are machine-readable: a bad call returns a clean status with the list of available endpoints and a repair hint, so an agent (or you) can recover or trigger a fix instead of failing silently. Confirmed failures feed the automatic repair queue.
Common use cases
  • Display the full food menu with EUR prices and multilingual descriptions on a travel or restaurant-finder site.
  • Show the desserts menu separately by passing menu=desserts to the get_menu endpoint.
  • Surface the per-person cover charge (cover_charge.price_eur) alongside reservation information.
  • Use section-level price_summary values to show price ranges per category (e.g., antipasti vs. secondi).
  • Detect menu edition changes by monitoring the document_name field for updated timestamps.
  • Build a price comparison tool for Lake Garda restaurants using price_summary.avg_eur and price_summary.min_eur.
  • Render ingredient and translation lines from descriptions arrays for German or English-speaking visitors.
Pricing & limitsSee full pricing →
TierPriceCredits/monthRate limit
Free$0/mo2005 req/min
Hobby$30/mo1,00020 req/min
Developer$100/mo5,000100 req/min
Team$300/mo20,000300 req/min
Company$1,000/mo100,000500 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.

Frequently asked questions
Does osteria-peschieradelgarda.it have an official developer API?+
No. The site does not publish a public developer API or documented data feed.
How does the menu parameter work, and what happens if I omit it?+
The menu parameter is optional and accepts food or desserts. When omitted, the API returns the default published menu (food). The selected value is echoed back in the response menu field so you can confirm which edition was returned.
Are dish availability or allergen details included in the response?+
Not currently. The API covers Italian dish names, EUR prices, multilingual description lines, and section notes as printed on the menu. Structured allergen data and real-time availability status are not exposed. You can fork it on Parse and revise to add the missing endpoint if that data becomes available on the source.
Does the API return historical menu editions for comparison?+
Not currently. The API returns the currently published menu and includes a document_name edition stamp to help detect changes. Past menu editions are not stored or queryable. You can fork it on Parse and revise to add historical tracking if you need version comparison.
What does sections[].price_summary return when a section has no priced items?+
When count is 0, the min_eur, max_eur, and avg_eur fields are all null. The count field itself is still returned as 0, so callers can check it before using the aggregate values.
Page content last updated . Spec covers 1 endpoint from osteria-peschieradelgarda.it.
Related APIs in Food DiningSee all →