Marcoedanielatime APImarcoedanielatime.it ↗
Access the published menu of Marco e Daniela Time restaurant (Peschiera del Garda) via API: sandwiches, dishes, drinks, vegan items, and price range.
What is the Marcoedanielatime API?
The Marco e Daniela Time API gives developers access to the restaurant's published menu through a single endpoint, get_menu_section, returning up to 8 response fields per call including item names, ingredient arrays, menu numbers, and the restaurant-wide price range. The endpoint covers sandwiches, cutting boards, drinks, and vegan specialties as grouped on the site, with support for both Italian and English language editions of the menu.
curl -X GET 'https://api.parse.bot/scraper/065cdf04-1140-4577-81ce-fdd7c4700f03/get_menu_section?section=sandwiches' \ -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 marcoedanielatime-it-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: browse the Marco e Daniela Time restaurant menu."""
from parse_apis.marcoedanielatime_it_api import (
MarcoEDanielaTime,
MenuSection,
Language,
InputFormatInvalid,
)
client = MarcoEDanielaTime()
# Fetch the sandwiches section in English.
sandwiches = client.sections.get(section=MenuSection.SANDWICHES)
print(f"{sandwiches.title} — {sandwiches.item_count} items, {sandwiches.price_range}")
if sandwiches.description:
print(sandwiches.description[:120])
# Walk each group and its menu items.
for group in sandwiches.groups:
heading = group.name or "(ungrouped)"
print(f"\n {heading}")
for item in group.items:
label = f"#{item.number} {item.name}" if item.number else (item.name or "(photo only)")
extras = ", ".join(item.ingredients) if item.ingredients else "no listed ingredients"
print(f" {label}: {extras}")
# Fetch the vegan section in Italian to show language switching.
try:
vegan_it = client.sections.get(section=MenuSection.VEGAN, language=Language.IT)
except InputFormatInvalid:
print("Section not available.")
else:
print(f"\n{vegan_it.title} ({vegan_it.language}) — {vegan_it.item_count} items")
print("\nexercised: sections.get (sandwiches EN, vegan IT)")
Returns one section of the restaurant's published menu in one page fetch: the section title, its introductory text, and its items grouped as the site groups them (groups[].name is null when the site shows no sub-heading). Each item carries the site's menu number and name (both null for untitled photo-only entries), its ingredient list (empty when the site lists none, as on the dishes/boards, drinks and vegan sections, which are photo galleries with titles only), and a photo URL. The site publishes no per-item prices; the only cost information it publishes is price_range, the restaurant-wide per-person range in euros (one shape: '5€-15€'), returned with currency. Content is in the language requested via language; group headings may remain in English on the Italian site.
| Param | Type | Description |
|---|---|---|
| sectionrequired | string | Which menu section to read. |
| language | string | Site language edition to read the section from. |
{
"type": "object",
"fields": {
"title": "section heading as shown on the site",
"groups": "array of item groups; each has name (sub-heading, nullable) and items (array of menu items with number, name, ingredients array, photo_url)",
"section": "the requested section code, echoed",
"currency": "ISO currency code of price_range (EUR), null when price_range is null",
"language": "the language edition read (en or it)",
"item_count": "total number of items across all groups",
"description": "introductory paragraph of the section, null when absent",
"price_range": "restaurant-wide published per-person price range string in euros, null when the site does not publish it"
},
"sample": {
"data": {
"title": "Sandwiches",
"groups": [
{
"name": "Classic Sandwiches",
"items": [
{
"name": "Marco",
"number": 1,
"photo_url": "https://www.marcoedanielatime.it/files/sezione/384_w_h_1.-Marco_384-1-Marco.jpg",
"ingredients": [
"Durum wheat bread",
"Raw Ham",
"Parmesan cheese",
"Balsamic vinegar cream"
]
}
]
},
{
"name": "Special Sandwiches",
"items": [
{
"name": "Unesco",
"number": 12,
"photo_url": "https://www.marcoedanielatime.it/files/sezione/407_w_h_12.-Unesco_407-396-12-Unesco.jpg",
"ingredients": [
"Durum wheat bread",
"Cotto Levoni",
"Artichoke with stem",
"Goat Robiola",
"Honey"
]
}
]
}
],
"section": "sandwiches",
"currency": "EUR",
"language": "en",
"item_count": 12,
"description": "For the simplicity of an excellent sandwich, the main ingredient is the BREAD, using selected durum wheat flours. Our sandwiches are not eaten ... they are enjoyed.",
"price_range": "5€-15€"
},
"status": "success"
}
}About the Marcoedanielatime API
What the API Returns
The single endpoint get_menu_section returns one section of the Marco e Daniela Time restaurant menu per call. Each response includes a title (the section heading as published), a description (the section's introductory paragraph, or null if absent), and a groups array that mirrors how the site organizes items. Each group carries a name field for sub-headings — null when the site shows no sub-heading — and an items array where each item includes a menu number, name, and ingredients array.
Section and Language Parameters
The required section input specifies which part of the menu to read: sandwiches, dishes, cutting boards, drinks, or vegan specialties. The optional language parameter selects between the Italian (it) and English (en) editions of the site, and the language edition actually read is echoed back in the language response field. The item_count field gives the total number of items across all groups in the response, so you can validate coverage without iterating the full groups array.
Price Range and Currency
The response includes a price_range field containing the restaurant's published per-person price range string in euros, drawn from the site's own published information. When the site does not publish this figure, the field returns null and the currency field (ISO code EUR) is also null. This makes it straightforward to surface pricing context alongside menu content without a separate request.
The Marcoedanielatime API is a managed, monitored endpoint for marcoedanielatime.it — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when marcoedanielatime.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 marcoedanielatime.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.
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?+
- Display the full Italian or English menu on a restaurant discovery app using section data from
get_menu_section - Build an ingredient filter tool that queries the
ingredientsarray to flag allergens or dietary preferences - Populate a vegan-specific menu view by fetching the vegan specialties section with
sectionset to the relevant code - Show per-person price range alongside menu items using the
price_rangeandcurrencyresponse fields - Sync a third-party food-ordering or reservation platform with the restaurant's current published menu structure
- Generate multilingual menu cards by fetching the same section in both
itandenlanguage editions
| 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 marcoedanielatime.it have an official developer API?+
What does the `groups` array in the response look like, and when is `name` null?+
groups has a name field (the sub-heading for that group of items) and an items array. When the site presents a section without any sub-heading, name is null and all items in that section appear under a single unnamed group. Each item carries a menu number, a name, and an ingredients array.Does the API cover opening hours, reservation details, or contact information?+
Can I retrieve the entire menu in a single call?+
get_menu_section returns one section per call, so you need a separate request for each section (sandwiches, drinks, vegan specialties, etc.). You can fork the API on Parse and revise it to add a combined endpoint that returns all sections at once.