Discover/Sanfernandocoffeeco API
live

Sanfernandocoffeeco APIsanfernandocoffeeco.com

Access San Fernando Coffee Company menus, prices, and customization options across all locations via 3 structured JSON endpoints.

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

What is the Sanfernandocoffeeco API?

The San Fernando Coffee Company API gives developers structured access to menu data across all locations through 3 endpoints. get_menu returns a full location menu in one call — every category, item, base price, stock status, and image URL. get_menu_item goes deeper, returning modifier groups (size, milk type, add-ons) with per-option price adjustments. list_locations enumerates every store with its slug, coordinates, address, and hours.

This call costs2 credits / call— charged only on success
Try it

No input parameters required.

api.parse.bot/scraper/ea42f2ae-aedd-451b-8f12-3a49c5a109a3/<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/ea42f2ae-aedd-451b-8f12-3a49c5a109a3/list_locations' \
  -H 'X-API-Key: $PARSE_API_KEY'
Python SDK · recommended

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 sanfernandocoffeeco-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: browse San Fernando Coffee locations, menus, and item customizations."""
from parse_apis.sanfernandocoffeeco_com_api import SanFernandoCoffee, InputNotFound

client = SanFernandoCoffee()

# List all store locations, capped to 5.
for loc in client.locations.list(limit=5):
    print(loc.name, loc.city, loc.state, loc.zipcode)

# Pick the first location and fetch its full menu.
location = client.locations.list(limit=1).first()
if location is not None:
    menu_data = location.menu()
    print(f"{menu_data.location_name} — {menu_data.item_count} items")
    print(f"  {menu_data.address.address1}, {menu_data.address.city}, {menu_data.address.state}")

    # Walk each menu's groups and print item summaries.
    for menu in menu_data.menus:
        print(f"\n{menu.name}")
        for group in menu.groups:
            print(f"  {group.name}")
            for item in group.items:
                stock = "" if not item.out_of_stock else " [OUT OF STOCK]"
                print(f"    ${item.price:.2f} — {item.name}{stock}")

    # Drill into the first item's detail to see customization options.
    first_group = next((g for m in menu_data.menus for g in m.groups if g.items), None)
    if first_group is not None:
        summary = first_group.items[0]
        try:
            detail = location.items.get(item_id=summary.item_id)
        except InputNotFound:
            print(f"Item {summary.item_id} not found at this location")
        else:
            print(f"\nDetail: {detail.name} — ${detail.price:.2f}")
            print(f"  {detail.description}")
            for mg in detail.modifier_groups:
                req = "required" if mg.required else "optional"
                print(f"  [{req}] {mg.name} (pick {mg.min_selections}–{mg.max_selections})")
                for opt in mg.options:
                    adj = f" +${opt.price:.2f}" if opt.price else ""
                    print(f"    {opt.name}{adj}")

print("\nexercised: locations.list / location.menu / location.items.get")
All endpoints · 3 totalmissing one? ·

Lists every San Fernando Coffee Company store that appears in the site's location picker, sorted by name. Each entry carries the location_slug accepted by get_menu and get_menu_item, the street address, phone, coordinates and the published weekly hours (an empty hours list means the site publishes none for that store). One round trip, no pagination.

Input

No input parameters required.

Response
{
  "type": "object",
  "fields": {
    "total": "number of locations returned",
    "locations": "array of store objects: location_slug (key for get_menu/get_menu_item), name, address, city, state, zipcode, phone, latitude, longitude, hours (array of {days, open, close} in 24h HH:MM local time)"
  },
  "sample": {
    "data": {
      "total": 20,
      "locations": [
        {
          "city": "Arcadia",
          "name": "ARCADIA",
          "hours": [
            {
              "days": [
                "monday",
                "tuesday",
                "wednesday"
              ],
              "open": "07:00",
              "close": "15:00"
            }
          ],
          "phone": "+1 (555) 012-3456",
          "state": "CA",
          "address": "289 West Huntington Drive, Suite 101",
          "zipcode": "91007",
          "latitude": 34.135727,
          "longitude": -118.042282,
          "location_slug": "san-fernando-coffee-inc-arcadia-289-west-huntington-drive-suite-101"
        }
      ]
    },
    "status": "success"
  }
}

About the Sanfernandocoffeeco API

Location Discovery

list_locations returns every San Fernando Coffee Company store available for online ordering. Each entry includes a location_slug — the identifier you pass to the other two endpoints — plus address, city, state, zipcode, phone, latitude, longitude, and published weekly hours. If the hours array is empty for a location, the site has not published hours for that store.

Full Menu by Location

get_menu accepts an optional location_slug parameter (defaults to the Rialto store when omitted) and returns the entire ordering menu in a single response. The top-level menus array is structured as menus → groups → items. Each item exposes item_id, name, description, group_id, a base price, an out_of_stock flag, and an image_url. The response also echoes location_name, location_slug, address, and an item_count for quick validation.

Item Customization Options

get_menu_item accepts a required item_id (a UUID sourced from get_menu) and an optional location_slug. It returns the item's full detail including calories (null when unpublished), prices (all base price points), and the modifier groups that drive the ordering form — things like size selection, milk alternatives, and extra shots. Each modifier group carries its selection rules, and every option within it includes its name and price adjustment in USD. If the item_id does not exist on the specified location's menu, the endpoint returns an error rather than empty data.

Reliability & maintenanceVerified

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

Last verified
1h ago
Latest check
3/3 endpoints 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
  • Build a menu display for a third-party ordering or kiosk app using item names, prices, and images from get_menu.
  • Show real-time out-of-stock warnings in a custom ordering UI by reading the out_of_stock flag per item.
  • Populate a drink configurator with size, milk, and add-on choices and their upcharges from get_menu_item modifier groups.
  • Render a store locator with coordinates, addresses, and hours sourced from list_locations.
  • Compare base prices and modifier pricing across multiple locations by iterating location_slug values.
  • Sync a local menu cache and detect price or availability changes by polling get_menu and diffing item_count and prices.
  • Build a calorie-aware menu filter using the calories field returned by get_menu_item.
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 San Fernando Coffee Company have an official developer API?+
No public developer API is documented on sanfernandocoffeeco.com. This Parse API is the available programmatic way to access their menu and location data.
What does `get_menu_item` return that `get_menu` does not?+
get_menu returns every item's base fields (name, price, description, stock flag, image) but does not include modifier groups. get_menu_item adds the full customization layer: modifier group names, selection rules (e.g. choose exactly one, choose up to three), and every option with its name and USD price adjustment. Calorie counts are also only present in get_menu_item responses.
What happens if I call `get_menu` without a `location_slug`?+
The location_slug parameter is optional on both get_menu and get_menu_item. When omitted, both endpoints default to the Rialto store at 466 East Foothill Boulevard. To retrieve data for another store, pass the location_slug value from list_locations.
Does the API cover past orders, loyalty accounts, or nutritional details beyond calories?+
No. The API covers menu structure, item prices, modifier options, stock status, and location data. Calories are returned by get_menu_item when the site publishes them, but other nutritional fields (fat, sodium, allergens) are not currently exposed. You can fork this API on Parse and revise it to add an endpoint targeting any additional nutritional data the site makes available.
Are hours always populated in `list_locations`?+
Not always. The hours field is an array of the published weekly schedule for each store. When a location has not published hours on the ordering site, the array is empty. Address, phone, and coordinates are still returned for those locations.
Page content last updated . Spec covers 3 endpoints from sanfernandocoffeeco.com.
Related APIs in Food DiningSee all →
farmersfridge.com API
Access Farmer's Fridge menu data, product details, kiosk locations, and real-time inventory. Browse the full menu or filter by category, retrieve nutrition facts and allergens for individual products, list kiosk locations by access or location type, and check live stock counts at any specific fridge.
elmariachimexicanfoodma.com API
elmariachimexicanfoodma.com API
crumblcookies.com API
Get Crumbl store locations (addresses, hours, and coordinates), this week’s rotating and classic cookie menu with details, and location-specific “secret menu” items like Hometown Picks and testing flavors.
hungrycoyotema.com API
hungrycoyotema.com API
bluebottlecoffee.com API
Browse Blue Bottle Coffee's complete product catalog, including roast levels, tasting notes, pricing, and customer reviews. List products by category, retrieve full details for any item, and explore cafe locations across all supported regions.
menupages.com API
Access restaurant menu data from MenuPages including all categories, items with descriptions and prices, plus customization options and modifiers. Search for specific menus or individual menu items to build restaurant catalogs, comparison tools, or delivery app integrations.
mcdonalds.com API
Browse McDonald's full menu and retrieve detailed nutritional information, allergens, and ingredients for any item. Get comprehensive product details to support menu exploration and nutrition-aware applications.
postmates.com API
Browse and search Postmates restaurants to discover menus, items, and detailed restaurant information all in one place. Get category suggestions, view complete menus, and access specific item details to find exactly what you're looking for.