danmurphys APIdanmurphys.com.au ↗
Retrieve beer product names, prices, volumes, and alcohol percentages from Dan Murphy's via a single API endpoint. Paginated results up to any requested limit.
What is the danmurphys API?
The Dan Murphy's Beer API exposes 4 data fields — product name, price, volume, and alcohol percentage — for beer listings from Australia's largest liquor retailer. The single get_beer_products endpoint returns a paginated, accumulating list of products you can cap with a limit parameter, making it straightforward to pull a targeted slice of the beer catalogue for price monitoring, product research, or inventory analysis.
curl -X GET 'https://api.parse.bot/scraper/7ee393f9-76bc-4423-95ac-a172a7d99aba/get_beer_products?limit=10' \ -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 danmurphys-com-au-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.
from parse_apis.dan_murphy_s_beer_api import DanMurphys
client = DanMurphys()
for product in client.beerproducts.list(limit=5):
print(product.name, product.price, product.volume, product.alcohol_percentage)
Retrieves beer products from Dan Murphy's beer category. Returns a paginated list of products with name, price, volume, and alcohol percentage. The upstream API is fetched in pages of 24; results are accumulated until the requested limit is reached. Products are sorted by relevance.
| Param | Type | Description |
|---|---|---|
| limit | integer | Maximum number of products to return. |
{
"type": "object",
"fields": {
"total": "integer - number of products returned in this response",
"products": "array of beer product objects each containing name, price, volume, and alcohol_percentage"
},
"sample": {
"data": {
"total": 10,
"products": [
{
"name": "Stone & Wood Pacific Ale Bottles 330mLx6",
"price": 81.95,
"volume": "330ML",
"alcohol_percentage": "4.4%"
}
]
},
"status": "success"
}
}About the danmurphys API
What the API Returns
The get_beer_products endpoint returns an array of beer product objects from Dan Murphy's beer category. Each object includes name (the product title as listed on the site), price (the current listed price), volume (package size, e.g. 375mL can or 750mL bottle), and alcohol_percentage (ABV as listed). The response also includes a total integer confirming how many products were returned in that call.
Pagination and the limit Parameter
Results are fetched in upstream batches of 24 and accumulated until the requested limit is satisfied. Pass limit as an integer to cap the number of products returned — for example, limit=50 will accumulate across multiple upstream pages until 50 products are gathered. Omitting limit returns all products the endpoint can accumulate from the beer category. Products are ordered by relevance as returned by the source.
Coverage and Scope
The API covers the beer category specifically. It surfaces the fields most relevant to price comparison and product cataloguing: name, price, volume, and ABV. It does not currently expose product images, stock availability, customer ratings, or product URLs. The data reflects publicly listed prices and product details for the Australian market.
The danmurphys API is a managed, monitored endpoint for danmurphys.com.au — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when danmurphys.com.au 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 danmurphys.com.au 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?+
- Track price changes on specific beer SKUs over time using the
nameandpricefields - Compare alcohol percentage across beer styles by filtering on
alcohol_percentage - Build a beer catalogue database with name, volume, and ABV for an Australian drinks app
- Monitor which beers fall within a target ABV range for health or regulatory compliance tools
- Analyse pricing per millilitre by combining the
priceandvolumefields - Feed product data into a recommendation engine that matches beers by size and alcohol content
| 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 Dan Murphy's have an official developer API?+
What exactly does `get_beer_products` return for each product?+
name (the product title), price (listed retail price), volume (package size such as 375mL or 750mL), and alcohol_percentage (ABV). The response wraps these in a products array alongside a total count of items returned.Does the API cover product images, ratings, or stock availability?+
Can I retrieve products from categories other than beer, such as wine or spirits?+
Are there any known limitations with the product data?+
limit parameter controls accumulation across upstream pages of 24, so very large limits will result in multiple internal fetches before the response is returned.