REMA 1000 APIshop.rema1000.dk ↗
Access REMA 1000's Danish grocery product catalog via API. Search products by keyword or department, paginate results, and list all departments with categories.
What is the REMA 1000 API?
The REMA 1000 API provides two endpoints covering the full Danish grocery product catalog at shop.rema1000.dk. The search_products endpoint returns paginated product records — including name, price, department, category, labels, and image URL — filtered by keyword or department ID. The list_departments endpoint exposes every department and its nested categories, giving you the IDs needed to scope product queries.
curl -X GET 'https://api.parse.bot/scraper/11d09981-ac4a-47b3-8665-e8b9744b0f72/search_products?page=1&sort=-popularity&query=m%C3%A6lk&per_page=5' \ -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 shop-rema1000-dk-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: REMA 1000 product catalog — browse departments, search products."""
from parse_apis.shop_rema1000_dk_api import Rema1000, Sort, InvalidInput
client = Rema1000()
# List all departments and their categories
for dept in client.departments.list(limit=5):
print(dept.name, f"({len(dept.categories)} categories)")
# Get one department and browse its products sorted by name
dept = client.departments.list(limit=1).first()
if dept:
for product in dept.products(sort=Sort.NAME_ASC, limit=3):
print(product.name, product.price, product.compare_unit)
# Search products within a department by keyword, sorted by popularity
dept = client.departments.list(limit=1).first()
if dept:
for product in dept.products(query="mælk", sort=Sort.POPULARITY_DESC, limit=3):
print(product.name, product.price, product.labels)
# Handle invalid input errors
try:
for p in dept.products(query="test", limit=1):
print(p.name)
except InvalidInput as exc:
print(f"Invalid input: {exc}")
print("exercised: departments.list / department.products (browse + search + sort enum)")
Search and list REMA 1000 products by keyword, optionally filtered by department. Results are sorted by popularity by default. When query is empty and a department_id is provided, returns all products in that department. Results are paginated with up to 100 items per page.
| Param | Type | Description |
|---|---|---|
| page | integer | Page number for pagination (1-based). |
| sort | string | Sort order for results. Use '-popularity' for most popular first, 'name' for alphabetical, '-name' for reverse alphabetical. |
| query | string | Search query string to match product names and descriptions. |
| per_page | integer | Number of products per page, between 1 and 100. |
| department_id | string | Department ID to filter products. Obtain from list_departments endpoint (e.g. 10, 20, 60). |
{
"type": "object",
"fields": {
"page": "integer",
"total": "integer",
"per_page": "integer",
"products": "array of product objects with id, name, underline, department, category, price, labels, image_url, etc."
},
"sample": {
"data": {
"page": 1,
"total": 5,
"per_page": 5,
"products": [
{
"id": 21464,
"name": "MINIMÆLK 0,4% FEDT",
"price": 10.5,
"labels": [
"REMA1000",
"Nøglehul",
"Dansk"
],
"barcodes": [
"5705830610065"
],
"category": "Mælk m.v.",
"image_url": "https://rema-product-images.digital.rema1000.dk/21464/1-large-AKqeJxY9p1.webp",
"underline": "1 LTR. / REMA 1000",
"department": "Mejeri",
"category_id": 6050,
"declaration": "<b>MINIMÆLK</b>",
"description": null,
"is_campaign": false,
"compare_unit": "ltr",
"department_id": 60,
"is_advertised": false,
"temperature_zone": "refrigerated_5_degrees_celsius",
"compare_unit_price": 10.5,
"is_available_in_all_stores": true
}
]
},
"status": "success"
}
}About the REMA 1000 API
Endpoints and Core Data
The API exposes two endpoints. search_products accepts a query string, a department_id, a sort order (-popularity, name, or -name), and pagination controls (page and per_page, up to 100 items per page). It returns a products array alongside total, page, and per_page fields so you can page through large result sets. Each product object includes id, name, underline, department, category, price, labels, and image_url.
Browsing by Department
list_departments requires no inputs and returns a flat array of department objects, each with id, name, slug, and a nested categories array. The id values map directly to the department_id parameter in search_products, letting you enumerate an entire department's inventory by passing an empty query alongside a valid department ID — for example, department IDs like 10, 20, or 60.
Filtering and Sorting
When both a query and a department_id are provided, results are filtered to that department. Omitting query while supplying a department_id returns all products in that department. The default sort is -popularity (most popular first), with name and -name available for alphabetical ordering. This makes the API suitable for both search-box use cases and full catalog ingestion.
The REMA 1000 API is a managed, monitored endpoint for shop.rema1000.dk — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when shop.rema1000.dk 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 shop.rema1000.dk 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 grocery price tracker that monitors REMA 1000 product prices over time using the
pricefield fromsearch_products - Populate a meal-planning app with products filtered by department, using
department_idfromlist_departments - Compare Danish supermarket product catalogs by mapping REMA 1000 departments and categories against competitors
- Detect when new product labels appear in REMA 1000's catalog by monitoring the
labelsfield - Create a diet or nutrition app that lets users search REMA 1000 products by keyword and browse by food category
- Build a shopping list tool that resolves product images and names using
image_urlandnamefields
| 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 REMA 1000 offer an official developer API?+
What does each product object in `search_products` contain?+
id, name, underline (a short descriptor), department, category, price, labels (such as promotional or dietary tags), and image_url. Pagination metadata — total, page, and per_page — is returned at the top level alongside the products array.Is individual product detail data — like nutritional information or allergen lists — available?+
How does pagination work in `search_products`?+
page (starting at 1) and per_page (1–100). The response includes a total count of matching products, so you can calculate the number of pages needed to retrieve a full result set.