hungrycoyotema APIhungrycoyotema.com ↗
Search the Hungry Coyote restaurant menu by item name. Returns price, description, category, and pickup ordering availability via one API endpoint.
What is the hungrycoyotema API?
The Hungry Coyote API gives developers programmatic access to the restaurant's menu through 1 endpoint, search_menu_item, which returns up to 4 structured fields per menu item: name, price, description, and category. It also surfaces a pickup_available flag indicating whether the restaurant is currently accepting pickup orders. Searches are case-insensitive and support partial name matching.
curl -X GET 'https://api.parse.bot/scraper/1252f3e6-a452-45eb-888e-c895c3e98748/search_menu_item?item_name=California+burrito' \ -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 hungrycoyotema-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: Search the Hungry Coyote menu and check pickup availability."""
from parse_apis.hungrycoyotema_com_api import HungryCoyote, InputFormatInvalid
client = HungryCoyote()
# Search for a menu item by name
try:
result = client.search_results.search(item_name="Chicken Grande Burrito")
except InputFormatInvalid as e:
print(f"Invalid search input: {e.message}")
raise
# Check whether the item exists on the menu
if result.found and result.item is not None:
print(f"Found: {result.item.name}")
print(f" Price: {result.item.price}")
print(f" Category: {result.item.category}")
if result.item.description:
print(f" Description: {result.item.description}")
else:
print(f"'{result.search_query}' was not found on the menu.")
# Pickup ordering status
print(f"Pickup available: {result.pickup_available}")
print("exercised: search_results.search")
Search the Hungry Coyote menu for a specific item by name. Returns whether the item is found, its price, description/ingredients (if available), category, and whether pickup ordering is available at the restaurant. The search is case-insensitive and matches partial names. Makes two requests: one to the menu page and one to the locations page for pickup status.
| Param | Type | Description |
|---|---|---|
| item_namerequired | string | Name of the menu item to search for (case-insensitive, partial match supported). E.g. 'California burrito', 'Chicken Grande Burrito'. |
{
"type": "object",
"fields": {
"item": "Object with item details (name, price, description, category) or null if not found",
"found": "Whether the item was found on the menu (boolean)",
"search_query": "The item name that was searched for",
"pickup_available": "Whether pickup ordering is available at the restaurant (boolean)"
},
"sample": {
"data": {
"item": null,
"found": false,
"search_query": "California burrito",
"pickup_available": true
},
"status": "success"
}
}About the hungrycoyotema API
What the API Returns
The single search_menu_item endpoint accepts an item_name string and returns a found boolean, the original search_query, a pickup_available boolean, and an item object. The item object carries four fields: name, price, description (which may include ingredients when the restaurant publishes them), and category. If no match is found, item is null and found is false.
Search Behavior
The item_name parameter supports partial matching, so querying "burrito" will return a match for "California burrito" without requiring the full name. Matching is case-insensitive, so "california burrito" and "California Burrito" produce the same result. This makes it practical for fuzzy lookup scenarios, such as checking whether a remembered item is still on the menu.
Pickup Availability
Every response includes pickup_available regardless of whether the searched item exists. This lets an application display an accurate ordering status to the user in the same call that checks the item — no second request needed to determine whether the restaurant is currently taking pickup orders.
The hungrycoyotema API is a managed, monitored endpoint for hungrycoyotema.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when hungrycoyotema.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 hungrycoyotema.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?+
- Display current menu item prices on a restaurant finder or food discovery app
- Check whether a specific dish (e.g. a California burrito) is on the Hungry Coyote menu before recommending it
- Build a chatbot that answers questions about menu items and pickup availability in a single response
- Alert users when pickup ordering becomes available at Hungry Coyote
- Pull menu category data to organize or filter items in a third-party food ordering interface
- Verify ingredient or description details for dietary or allergy screening tools
| 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 Hungry Coyote have an official developer API?+
What does search_menu_item return when an item is not found?+
found to false and item to null. The search_query field still echoes the input, and pickup_available still reflects current pickup status, so you get useful operational data even for a failed item lookup.Does the API return a full menu list, or only single-item lookups?+
item_name parameter. Full menu enumeration is not exposed as a separate endpoint. You can fork this API on Parse and revise it to add a full menu listing endpoint.Is description or ingredient data always present in the item object?+
description field is returned when the restaurant publishes that information for a given item. For items where no description is listed, the field may be empty or absent. Only data the restaurant makes available on their menu is included.