Legami APIlegami.com ↗
Access Legami's product catalog, basket management, and boutique store locator via 7 structured endpoints. Search products, get SKU details, and find store locations.
What is the Legami API?
The Legami.com API covers 7 endpoints for searching the product catalog, fetching full SKU details, managing shopping baskets, and locating physical boutique stores. The search_products endpoint returns paginated product arrays alongside refinement filters and sort options, while get_product_details supports batch retrieval of multiple SKUs in a single call — making it straightforward to build product feeds or comparison tools against Legami's stationery and gift inventory.
curl -X GET 'https://api.parse.bot/scraper/b361a643-6954-4674-aa6c-b8fb51cc5df6/search_products?limit=12&query=notebook&offset=0' \ -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 legami-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: Legami E-commerce API — search products, get details, manage baskets, find stores."""
from parse_apis.legami_e_commerce_api import Legami, ProductNotFound
client = Legami()
# Search for notebooks — limit caps total items fetched.
for product in client.products.search(query="notebook", limit=5):
print(product.id, product.product_name, product.available)
# Get detailed product info by SKU.
for detail in client.products.get_details(product_id="GEP0074", limit=1):
print(f"Detail: {detail.name}, price: {detail.price_per_unit}, category: {detail.primary_category_id}")
# Create a basket and add an item.
basket = client.baskets.create()
print(f"Basket: {basket.basket_id}, currency: {basket.currency}")
updated = client.baskets.add_item(product_id="VEP0074", quantity=2)
print(f"After add: basket={updated.basket_id}, total={updated.order_total}")
# Check basket count for current session.
count_info = client.baskets.count()
print(f"Baskets in session: {count_info.total}")
# Get store directory.
directory = client.storedirectories.list()
print(f"Store directory loaded: {type(directory.stores)}")
# Typed error handling.
try:
pen = client.products.search(query="penna", limit=1).first()
if pen:
print(f"Found pen: {pen.product_name} ({pen.id})")
except ProductNotFound as exc:
print(f"Product not found: {exc.product_id}")
print("exercised: products.search / products.get_details / baskets.create / baskets.add_item / baskets.count / storedirectories.list")
Full-text search over the Legami product catalog. Returns paginated results including product tiles with pricing, images, variation swatches, and available refinement filters. Pagination via offset; each page returns up to `limit` items from a total `count`.
| Param | Type | Description |
|---|---|---|
| limit | integer | Max results per page. |
| queryrequired | string | Search keyword (e.g. 'notebook', 'penna', 'zaino'). |
| offset | integer | Pagination offset (number of results to skip). |
{
"type": "object",
"fields": {
"count": "integer total number of matching products",
"pageSize": "integer number of results in this page",
"products": "array of product objects with id, productName, price, images, variationAttributes",
"productSort": "object with available sorting options",
"refinements": "array of available filter options (color, theme, etc.)"
},
"sample": {
"data": {
"count": 95,
"pageSize": 10,
"products": [
{
"id": "GMYNOT0263",
"price": {
"sales": {
"value": 9.95,
"currency": "EUR",
"formatted": "€ 9,95"
}
},
"images": {
"medium": [
{
"url": "https://www.legami.com/dw/image/v2/BDSQ_PRD/on/demandware.static/-/Sites-legami-master-catalog/default/dw1b179e27/images_legami/zoom/MYNOT0263_1.jpg?sw=400&sh=400"
}
]
},
"productName": "Taccuino a Righe con Copertina Morbida Monocolore - Chartreuse - My Notebook"
}
],
"productSort": {
"options": [
{
"id": "raccomandati",
"displayName": "Raccomandati"
}
]
},
"refinements": [
{
"values": [
{
"hitCount": 1,
"displayValue": "MAP"
}
],
"displayName": "Tema"
}
]
},
"status": "success"
}
}About the Legami API
Product Search and Discovery
The search_products endpoint accepts a query string (e.g. 'notebook' or 'penna') with optional limit and offset parameters for pagination. The response includes a count of total matching products, a products array with per-item id, productName, price, images, and variationAttributes, plus a refinements array listing available filters such as color and theme. A productSort object enumerates the available sort orders. If a query triggers an automatic redirect on the site, searchRedirect returns the target URL instead of a results list.
Product Detail and Category Lookup
get_product_details takes a product_id that can be a single SKU like 'GEP0074' or a comma-separated batch string like 'GEP0074,VSKA0001'. Each item in the returned data array includes name, pricePerUnit, variants, variationAttributes, images, descriptions, and ratings. The list_categories endpoint accepts an optional query and returns categorySuggestions (with a categories array and suggestedPhrases), productSuggestions, and brandSuggestions — useful for building autocomplete or navigation trees.
Basket and Cart Management
Three endpoints handle cart state. create_basket creates a new session basket and returns its basketId, currency (EUR), orderTotal, creationDate, and customerInfo. get_basket retrieves the current session's basket count. add_to_cart accepts a product_id (variant-level, e.g. 'VEP0074') and an optional quantity; it auto-creates a basket if none exists and returns the updated orderTotal and productSubTotal.
Store Locator
find_boutique returns a stores object keyed by country code (e.g. 'IT'), with each country further divided by region. Each store record includes id, name, address, city, phone, hours, and services. This makes it usable for store-finder UIs or geographic analysis of Legami's retail footprint without any additional filtering parameters.
The Legami API is a managed, monitored endpoint for legami.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when legami.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 legami.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 product feed for Legami stationery and gifts using
search_productswith keyword and pagination parameters - Fetch full variant-level pricing and ratings for multiple SKUs in one call via the batch mode of
get_product_details - Power an autocomplete search UI using
list_categoriesto surface category and product suggestions as users type - Implement a cart workflow — create basket, add variants, and retrieve totals — using the three basket endpoints
- Render a store-finder map using country, region, address, and hours data from
find_boutique - Track price and variant changes across specific SKUs by polling
get_product_detailson a schedule - Filter Legami products by color or theme by reading the
refinementsarray fromsearch_productsresponses
| 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 Legami have an official public developer API?+
What does `get_product_details` return that `search_products` does not?+
search_products returns summary fields suitable for listing pages: productName, price, images, and variationAttributes. get_product_details adds pricePerUnit, full descriptions, ratings, and the complete variants array — data typically shown on a product detail page. It also supports batch retrieval via a comma-separated product_id string, so you can resolve multiple SKUs in one request.Are order history or user account details available through this API?+
Does `find_boutique` support filtering stores by country or city?+
stores response object. Client-side filtering by country or city is needed to narrow results. You can fork this API on Parse and revise it to add server-side filtering parameters.What currency does the basket and pricing data use?+
orderTotal, productSubTotal, and pricePerUnit — are denominated in EUR. The currency field in basket responses explicitly returns 'EUR'. Multi-currency support is not currently part of the API.