Slicelife APIslicelife.com ↗
Search pizza restaurants by location, retrieve full menus with prices and add-ons, and get delivery details via the Slice (slicelife.com) API.
What is the Slicelife API?
The Slice API gives developers access to 4 endpoints covering pizza restaurant discovery, detailed restaurant profiles, full menus, and city coverage across the United States. The search_restaurants endpoint lets you query by latitude/longitude or address and returns delivery fees, ratings, review counts, and availability status for each result. Menu data goes deep — categories, item prices, product sizes, and add-on selections are all present in get_restaurant_menu responses.
curl -X GET 'https://api.parse.bot/scraper/84f140a0-0f54-4f3c-9dae-c72a75904276/search_restaurants?limit=5&offset=0&radius=5&address=New+York%2C+NY&latitude=40.7128&longitude=-74.006' \ -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 slicelife-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: Slice Pizza SDK — search restaurants, get details, browse menus, list cities."""
from parse_apis.slice_pizza_api import Slice, RestaurantSummary, Restaurant, MenuCategory, CityDirectory, RestaurantNotFound
slice_client = Slice()
# Search for pizza restaurants near NYC coordinates
for restaurant in slice_client.restaurants.search(latitude=40.7128, longitude=-74.006, radius=5, limit=3):
print(restaurant.name, restaurant.rating, restaurant.is_open_for_delivery)
# Drill into one restaurant's full details
summary = slice_client.restaurants.search(latitude=40.7128, longitude=-74.006, limit=1).first()
if summary:
details = summary.details()
print(details.name, details.delivery_estimate, details.does_delivery, details.minimum_order_delivery)
# Browse the restaurant's menu categories and items
for category in details.menu.list(limit=3):
print(category.name)
for product in category.products[:2]:
print(product.name, product.product_types[0].price, product.description)
# Fetch the full city directory
directory = slice_client.citydirectories.fetch()
print(len(directory.states), "states available")
# Typed error handling for a non-existent restaurant
try:
bad_summary = RestaurantSummary(_api=slice_client, id="00000000-0000-0000-0000-000000000000", name="", slug="", phone="", city="", state="", address="", web_slug="", zip_code="", is_pickup_only=False, is_open_for_pickup=False, is_open_for_delivery=False)
bad_summary.details()
except RestaurantNotFound as exc:
print(f"Restaurant not found: {exc.restaurant_id}")
print("exercised: restaurants.search / details / menu.list / citydirectories.fetch / RestaurantNotFound")
Search for pizza restaurants near coordinates or an address. Returns a list of restaurants with delivery fees, ratings, and availability status. Use limit and offset for pagination. When using address, geocoding quality varies; providing latitude/longitude directly yields more reliable results.
| Param | Type | Description |
|---|---|---|
| limit | integer | Maximum number of results to return. |
| offset | integer | Pagination offset for results. |
| radius | integer | Search radius in miles. |
| address | string | Address string for geocoding (e.g. 'Brooklyn, NY'). Used only if latitude/longitude are not provided. Geocoding quality varies for generic city names; prefer coordinates for precision. |
| latitude | number | Latitude of search center (e.g. 40.7128). If omitted along with longitude and address, defaults to New York City. |
| longitude | number | Longitude of search center (e.g. -74.0060). If omitted along with latitude and address, defaults to New York City. |
{
"type": "object",
"fields": {
"total": "integer total number of matching restaurants",
"restaurants": "array of restaurant summary objects with id, name, address, city, state, zip_code, phone, rating, review_count, delivery_fee, minimum_order, is_pickup_only, is_open_for_delivery, is_open_for_pickup, slug, web_slug"
},
"sample": {
"data": {
"total": 5,
"restaurants": [
{
"id": "26e8cba3-c4e9-4245-9a55-b3b37862e5e9",
"city": "New York",
"name": "Bleecker's Finest Deli",
"slug": "bleecker-s-finest-deli",
"phone": "+1 (555) 012-3456",
"state": "NY",
"rating": 4.47,
"address": "171 Bleecker St",
"web_slug": "ny/new-york/10012/bleecker-s-finest-deli",
"zip_code": "10012",
"delivery_fee": 6.45,
"review_count": 26,
"minimum_order": 23,
"is_pickup_only": false,
"is_open_for_pickup": true,
"is_open_for_delivery": true
}
]
},
"status": "success"
}
}About the Slicelife API
Restaurant Search and Discovery
The search_restaurants endpoint accepts a latitude/longitude pair or a freeform address string and returns a paginated list of pizza restaurants. Use limit and offset to page through results. Each restaurant summary includes id, name, address, city, state, zip_code, phone, rating, review_count, and delivery_fee. The total field tells you how many results exist for a given query, which is useful for building pagination controls. Supplying latitude and longitude directly produces more reliable results than address-based geocoding.
Restaurant Details and Menus
get_restaurant_details accepts a restaurant UUID (the id field from search results) and returns the full profile: phone, website, description, web_slug, state, zip_code, and delivery/pickup availability with estimated times and minimum order amounts. get_restaurant_menu uses the same UUID and returns a structured menu broken into categories — each category contains a products array with item prices, descriptions, size variants (product_types), and available add-ons with their selection options.
Geographic Coverage
get_all_cities requires no parameters and returns every state and city currently listed on Slice, structured as an object keyed by two-letter state code. Each city entry includes a name and slug. This is useful for building location pickers or auditing which markets Slice covers before running searches. Coverage is U.S.-only and reflects the restaurants that have active listings on the platform.
The Slicelife API is a managed, monitored endpoint for slicelife.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when slicelife.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 slicelife.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 pizza finder app using
search_restaurantsfiltered by radius and sorted by rating - Aggregate delivery fee data across cities to compare Slice restaurant pricing by market
- Populate a menu display with category names, item prices, and add-on options from
get_restaurant_menu - Generate a city-level coverage map using state and city slugs from
get_all_cities - Track restaurant availability and estimated delivery times using
get_restaurant_details - Compile a directory of pizza restaurant phone numbers and websites for a local business dataset
- Monitor review counts and ratings for restaurants in a target city over time
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does Slice have an official developer API?+
What does `search_restaurants` return beyond a restaurant name and address?+
rating, review_count, delivery_fee, phone, zip_code, and an availability status. The total field reflects the full count of matching restaurants for the query, enabling accurate pagination with limit and offset.How detailed is the menu data in `get_restaurant_menu`?+
categories, each containing a products array. Products include prices, descriptions, size variants (product types), and add-ons with their available selections. The endpoint does not currently return real-time item availability or out-of-stock flags. You can fork the API on Parse and revise it to add any additional menu fields that become available.Does the API cover order placement or user account data?+
How reliable is address-based search compared to coordinate-based search?+
address parameter goes through geocoding that can vary in accuracy depending on how specific the input string is. Providing latitude and longitude directly bypasses that step and consistently returns results centered on the exact coordinates supplied.