Intelligentsia APIintelligentsia.com ↗
Access Intelligentsia Coffee's full product catalog, collections, variants, and pricing via 8 endpoints. Search coffees, filter by collection, and retrieve SKU-level data.
What is the Intelligentsia API?
This API exposes 8 endpoints against intelligentsia.com, covering coffee products, merchandise, subscriptions, and curated collections. Use list_all_coffee_products to pull every coffee and espresso listing in one call, or get_product_variants_and_pricing to retrieve SKU-level fields like price, barcode, weight, and compare_at_price for a specific product handle. All paginated collection endpoints fetch every page automatically.
No input parameters required.
curl -X GET 'https://api.parse.bot/scraper/9b8b56dc-10c2-46ce-931e-ab62d4512192/list_all_coffee_products' \ -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 intelligentsia-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: Intelligentsia Coffee SDK — search, browse collections, drill into variants."""
from parse_apis.intelligentsia_coffee_api import Intelligentsia, ProductNotFound
client = Intelligentsia()
# Search for espresso products
for result in client.products.search(query="espresso", limit=3):
print(result.title, result.price, result.available)
# Get full product details by handle
product = client.products.get(handle="black-cat-classic-espresso")
print(product.title, product.vendor, product.product_type)
for variant in product.variants:
print(variant.title, variant.price, variant.sku, variant.barcode)
# List coffee products from the main collection
coffee = client.products.list_coffee(limit=3).first()
if coffee:
# Drill into variant pricing via instance method
for v in coffee.variants_and_pricing(limit=5):
print(v.title, v.price, v.weight, v.weight_unit)
# Navigate collections → sub-resource products
blends = client.collection(handle="blends")
for p in blends.products.list(limit=3):
print(p.title, p.handle)
for img in p.images:
print(img.src, img.width, img.height)
# Typed error handling for a missing product
try:
client.products.get(handle="nonexistent-product-xyz")
except ProductNotFound as exc:
print(f"Product not found: {exc.handle}")
print("exercised: products.search / products.get / products.list_coffee / variants_and_pricing / collection.products.list")
Returns all coffee and espresso products from the main coffee collection. Fetches all pages automatically. Each product includes full variant details, images, tags, and pricing.
No input parameters required.
{
"type": "object",
"fields": {
"total": "integer total number of products returned",
"products": "array of product objects with id, title, handle, body_html, variants, images, tags, and pricing"
},
"sample": {
"data": {
"total": 32,
"products": [
{
"id": 4528557097020,
"tags": [
"Badge: Best Seller",
"Coffee Type: Espresso - Blend"
],
"title": "Black Cat Classic Espresso",
"handle": "black-cat-classic-espresso",
"images": [
{
"id": 45354694541372,
"src": "https://cdn.shopify.com/s/files/1/0084/8802/6172/files/12oz_BC_Classic.png?v=1762379623",
"width": 1080,
"height": 1080
}
],
"vendor": "Intelligentsia Coffee",
"options": [
{
"name": "Size",
"values": [
"12 oz",
"5 lb"
]
}
],
"variants": [
{
"id": 32092748382268,
"sku": "5913",
"grams": 340,
"price": "17.50",
"title": "12 oz",
"available": true
}
],
"body_html": "<p>Black Cat Classic is our hallmark espresso blend...</p>",
"product_type": "Coffee",
"published_at": "2025-06-20T14:17:46-05:00"
}
]
},
"status": "success"
}
}About the Intelligentsia API
Product and Collection Data
list_all_coffee_products returns the full coffee catalog as an array of product objects, each containing id, title, handle, body_html, tags, images, variants, and pricing. list_products_by_collection narrows results to a specific collection by passing a collection_handle string such as blends, all-espresso, or single-origin. To discover valid handles, call list_all_collections first — it returns every collection's id, title, handle, description, published_at, and products_count.
Variant and Pricing Detail
get_product_variants_and_pricing takes a product handle and returns an array of variant objects. Each variant includes id, title, price, sku, weight, barcode, compare_at_price, and availability status. This is the right endpoint when you need to compare grind options or bag sizes on a single product rather than pulling the full catalog. get_product_details returns the same handle-scoped data but adds vendor, product_type, full options arrays, and all image records.
Search and Specialty Collections
search_products accepts a free-text query (e.g. ethiopia, blend) and returns a resources object with a products array containing id, title, handle, price, image, and url. It searches across all product types on the site, not just coffee. list_goods_products isolates non-coffee merchandise like brewing equipment and accessories, while list_subscription_products returns only products in the coffee filter subscriptions collection — useful if you need to distinguish subscription-eligible SKUs from one-time purchases.
The Intelligentsia API is a managed, monitored endpoint for intelligentsia.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when intelligentsia.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 intelligentsia.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 price-tracking tool that monitors
compare_at_pricevs.priceacross all coffee variants to detect discounts. - Populate a coffee discovery app with origin and blend details from
body_htmlandtagsreturned bylist_all_coffee_products. - Sync a product catalog to an internal database using
list_products_by_collectionwith handles likesingle-originorblends. - Extract barcode and SKU data from
get_product_variants_and_pricingfor inventory or retail integration. - Power a faceted search UI by combining
list_all_collectionsfor filter options withlist_products_by_collectionfor results. - Identify subscription-eligible SKUs separately from retail products using
list_subscription_products. - Compare grind size and bag weight options by parsing variant
titleandweightfields fromget_product_details.
| 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 Intelligentsia Coffee have an official developer API?+
/products.json), but Intelligentsia does not publish an official developer API or documentation for third-party use.What does `get_product_variants_and_pricing` return that `list_all_coffee_products` does not?+
get_product_variants_and_pricing focuses exclusively on variant-level fields for a single product: sku, barcode, weight, compare_at_price, and per-variant availability. The list endpoints include variants too, but are optimized for catalog-wide retrieval rather than per-SKU detail.How do I find valid collection handles to use with `list_products_by_collection`?+
list_all_collections first. It returns every collection object with a handle field (e.g. blends, all-espresso, single-origin) that you pass directly as the collection_handle parameter.Does `search_products` search only coffee, or all product types?+
search_products queries across the full site, so a term like espresso may return both coffee products and brewing equipment. The response groups results inside a resources object with a products array; there is no built-in type filter on the search endpoint itself.