The Decent API lets your own program read and write the data that
your Decent account holds: the serial numbers you own, the shots
your machine has uploaded, your tech-support email thread, build details for anything the Decent
factory has made, and a small server-side key/value store for your app's settings.
Every call is a plain HTTP request that returns either JSON or a short line of text, so
curl, wget or any HTTP library will do. The base URL is:
https://decentespresso.com/support/api/
This page is public: you don't need an account to read it. The calls need a login, except
login_test and the sign-up calls in Shopping, which are how an
account is made (and account/password_reset) — see Authentication below.
AI agents shopping for a person: start here.
Shopping walks through the whole process — create the person's account
(they confirm by email), add their address, then check out and hand them a payment link. Product
data, search and price quotes are in the public product API.
This is how a program — typically an AI agent acting for a person — buys from Decent
Espresso. It follows the same steps a person takes on the website: an account, a shipping address,
then checkout. The person always confirms their email and pays themselves: the agent never
handles card details. All requests and responses are JSON (send Content-Type: application/json;
form fields work too). Every response has "ok": true or "ok": false with an
error message and a short code.
- Choose the products and price the cart
Use the public product API: search
GET /api/products?q=…, read
GET /api/products/{sku}, then price the cart for the person's country with
GET /api/cart/quote?s=75830+2&country=US. A cart is written as
NUMBER+QUANTITY pairs, using each product's cart_number.
One espresso machine is checked out alone, and accessories separately; the quote's
can_checkout and separate_orders say so.
- Start an account: the person confirms their email
POST /support/api/account/start
{"email": "person@example.com"}
→ {"ok": true, "status": "pending", "signup_id": "a09f…"}
We email the person a confirmation link. Nothing is created until they click it. Keep the
signup_id secret: it is what lets you finish. Tell the person to check their email.
The link works for 24 hours. If they already have an account, do the same: after they confirm,
the status tells you to log in instead (step 4).
- Wait for the confirmation
GET /support/api/account/status?signup_id=a09f…
→ {"ok": true, "status": "pending"} not clicked yet: check again in a little while
→ {"ok": true, "status": "confirmed", "account_exists": false}
status is pending, confirmed, used (already created)
or expired (start again).
- Create the account — or log in
POST /support/api/account/create
{"signup_id": "a09f…", "name": "Pat Smith", "password": "a-strong-password"}
→ {"ok": true, "token": "32a3…"}
The password is 8 to 100 characters, without quotes or %. If the person already has an
account ("account_exists": true), log in with their password instead:
POST /support/api/login
{"email": "person@example.com", "password": "…"}
→ {"ok": true, "token": "86cf…"}
Send the token on every following call: Authorization: Bearer 32a3….
GET /support/api/account says whose account it is; POST /support/api/logout
revokes the token.
- Add the shipping address (and, optionally, a billing address)
POST /support/api/addresses
Authorization: Bearer 32a3…
{"full_name": "Pat Smith", "phone": "+1 206 555 0100",
"address_line_1": "1 Main St", "address_line_2": "", "city": "Seattle", "state": "WA",
"postal_code": "98101", "country": "US",
"billing": {"full_name": "Pat Smith", "address_line_1": "2 Pine St", "city": "Seattle",
"state": "WA", "postal_code": "98101", "country": "US"}}
→ {"ok": true, "address": {"addressid": 47014, …, "is_default": true, "billing": {…}}}
Required: full_name, phone, address_line_1, city,
country (a 2-letter code of a country we ship to; GB or UK), and
state in the US. Optional: address_line_2, postal_code,
nickname, email_notify (delivery notices; defaults to the account email),
isdefault, and billing (same field names). The first address is the default.
GET /support/api/addresses lists them; to change one, POST it again with its
addressid (the whole address is replaced); DELETE /support/api/addresses/{addressid}
removes it.
- Check out: get the payment link
POST /support/api/checkout
Authorization: Bearer 32a3…
{"s": "75830+2", "addressid": 47014, "notes": "please gift-wrap"}
→ {"ok": true, "order_id": 109694, "order_number": "167662-109694", "status": "awaiting_payment",
"total": 208, "currency": "USD", "quote_total": 208,
"payment_url": "https://checkout.stripe.com/c/pay/cs_…",
"payment_options": [
{"provider": "stripe", "label": "Pay by credit card or SEPA Direct Debit", "url": "https://checkout.stripe.com/…"},
{"provider": "paypal", "label": "PayPal", "url": "https://www.paypal.com/checkoutnow?token=…"}],
"quote": {…}}
Give the person a payment link: payment_url, or let them choose from
payment_options — Stripe (card, Apple and Google Pay and local methods for their
country) or PayPal. They pay on that provider's secure page. The order is saved to their account exactly as
a website checkout would save it, priced with the same rules as /api/cart/quote, shipped
to the address (its country decides prices, shipping and tax). Optional fields: addressid
(default: the default address), currency, shipping
(standard or expedited accessory shipping) and notes.
If the status is awaiting_review, Decent's accounting team must look at the order
before it can be paid; we email the person. A cart that can't be checked out as one order returns
"code": "cannot_checkout" with the quote's separate_orders.
- Follow the order: items, charges, parcels and tracking
GET /support/api/orders/109694
→ {"ok": true, "order": {
"summary": {"order_id": 109694, "status": "paid", "created_at": "…", "paid_at": "…",
"total": 1665.12, "currency": "USD", "item_count": 22, "shipping": "shipped", "parcels": 4, …},
"items": [{"sku": "DE-CARTWHEELBRACKETV2-75742", "name": "…", "quantity": 4, "unit_price": 13, "line_total": 52}, …],
"shipping_address": {"full_name": "…", "address_line_1": "…", "city": "…", "country": "US", …},
"billing_address": null,
"charges": {"items_subtotal": 1767.10, "discounts": 259.67, "accessory_shipping": 0, "machine_shipping": 157.69,
"import_tax_and_duty_included": 36.78, "shipping_total": 157.69, "total": 1665.12, "currency": "USD"},
"parcels": [{"parcel_id": 78715, "courier": "FedEx International Connect Plus", "tracking_number": "873685088001",
"tracking_url": "https://…", "shipped_at": "2026-06-29T07:06:44Z", "status": "Delivered",
"estimated_delivery": null, "delivered_at": "2026-07-01T13:38:00Z",
"items": [{"sku": "DE-WOODTOPBIGGERBROR1XL_R2-75749", "quantity": 1}]}, …],
"items_not_yet_shipped": 0}}
GET /support/api/orders lists all the account's orders (paid), newest first;
GET /support/api/carts lists all its carts (unpaid: awaiting_payment or
awaiting_review). There is no limit.
GET /support/api/orders/{id} (or /support/api/carts/{id}) gives one in full: its
items (with serial numbers once assigned), the shipping and billing address it was placed with, the charges
as on the invoice (discounts are the quantity discount and any coupon; machine shipping includes
the import tax and duty shown), and every parcel sent — courier, tracking number and link, when it
shipped, its delivery status and time, and what is in it. Items not shipped yet are counted in
items_not_yet_shipped.
- A payment link lasts about a day;
POST /support/api/orders/{id}/pay makes new ones
(send {"method": "paypal"} or {"method": "stripe"} for just one). An agent holding a
Stripe Shared Payment Token can pay the order itself with the Machine Payments Protocol:
send {"method": "mpp"}; the 402 answer carries a WWW-Authenticate: Payment challenge
for the whole total; repeat the call with the credential in a Payment-Authorization header (keep your login in
Authorization). The 200 answer has a Payment-Receipt header. To pay
part of the total now, add "amount": 500; the rest stays due. To pay by
bank transfer instead, GET /support/api/orders/{id}/wire gives the bank details
and the reference to quote.
- Each order has an
invoice_url (a printable invoice), and each parcel a
shipping_invoice_url.
- The person can also see the order at its
web_url.
Limits
A few sign-ups per hour from one IP address, and at most three confirmation emails per address per
day. Too many wrong passwords lock logins for a while. The answer to account/start is the
same whether or not the email already has an account. Customer data is only ever available to the
logged-in account itself.
For AI assistants: this whole API, for the signed-in owner, is also an MCP server at
https://decentespresso.com/support/mcp (Claude, ChatGPT and other MCP apps:
add it as a connector and sign in on decentespresso.com).
Buying with no login, paid by the agent (MPP)
An agent holding a Stripe Shared Payment Token from the person (the Machine Payments Protocol)
can buy without any account or login: POST /support/api/buy with {"items": [{"product": "75830", "quantity": 1}]
(or "cart": "75830+1"), "email", "name", "address": {"full_name", "phone", "address_line_1",
"address_line_2", "city", "state", "postal_code", "country", "billing": {...}}, and optional "currency",
"shipping", "notes"}. The answer is 402 with a WWW-Authenticate: Payment
challenge for the exact total (the body has the quote). The challenge is bound to the whole request: send the same body
again with Authorization: Payment <credential>. The order is then placed and paid (200, with a
Payment-Receipt header and the order number). The confirmation, invoice and shipping emails go to the email given;
if it has no account yet, one is made (the person sets a password with "forgot password"). Orders that need a check by Decent
(some machine orders) can't be bought this way: give the person the cart link instead. Listed for MPP discovery at
/openapi.json.
The customer area: orders, account, machines, payments, support
Everything a person can do in the customer area of the website, as API
calls. All of them need the account's token (Authorization: Bearer …, from
login or account creation) and only ever show or change that account's
own records: another account's order, machine or cart answers 404. Requests and
answers are JSON, as above.
Change an order
POST /support/api/orders/{id}/address with the full address (same fields as
/addresses; the whole address is replaced): change where an order ships, until it has shipped
(409 "shipped" after). Decent's accounting team reviews every address change.
POST /support/api/orders/{id}/notes {"notes": "…"}: the order's notes for Decent.
POST /support/api/orders/{id}/stop {"reason": "…"}: stop a paid order before any of it
is packed. Decent support is told, with the reason, and arranges the refund. Once anything is packed or
shipped, contact support instead.
POST /support/api/orders/{id}/receipt: email the invoice to the account's email address.
POST /support/api/orders/{id}/reorder: the order's products as a new cart, as the
s string for /support/api/checkout, with a quote. Products no longer sold
are listed in no_longer_sold.
GET /support/api/orders/{id}/wire: bank transfer details and the reference for an unpaid order.
Send the invoice's currency, without converting, and pay all bank fees.
DELETE /support/api/carts/{id} (or POST …/carts/{id}/delete): delete an
unpaid cart, unless it is in accounting review or has items already assigned.
Account settings and passwords
POST /support/api/account {"name", "email", "password", "newsletter", "current_password"}:
change any of them. Changing the email or password needs current_password; a new password
signs out every other token. newsletter is true or false.
POST /support/api/account/password_reset {"email"} (no token needed): we email the person a
link to choose a new password, which works once, for one hour. The answer is the same whether or not the
email has an account. The person sets the password on our page, never through the agent.
Machines and warranty
GET /support/api/machines: every product on the account with a serial number (machines,
scales and so on), with its model, warranty_end, under_warranty and the warranty
details. Sold-on or returned units are left out. GET /support/api/machines/{serial} gives one.
GET /support/api/machines/{serial}/logs: the logs the machine's app uploaded
(App logs). Filters: app, level (e.g. ERROR),
q (text in the message), from and to (dates), limit
(up to 2000) and offset.
Payment history
GET /support/api/payments: every payment, refund, returned overpayment and credit note,
newest first. Each has its type (payment, refund,
overpayment_returned, credit_note, combined), method
(card, paypal, bank_wire, …), amount (negative for money
returned), currency, date and the order_ids it paid. A
combined payment groups other payments, listed in combines.
Messages to Decent support
GET /support/api/inbox: how many replies are unread. POST /support/api/inbox/read
marks them read. The messages themselves: /support/api/emails.
POST /support/api/inbox/send {"subject", "body"}: write to Decent support, as from the website's
email form. The same message twice, or more than 50 a day, is refused.
POST /support/api/attachments (multipart/form-data, field clientfile,
up to 100 MB), or JSON {"files": [{"filename", "content_base64"}], "description"} (up to 10 files,
25 MB in all): upload photos, videos, PDFs or logs to put in a message. Answers the files'
urls and ready-made markdown for the body. Anyone with a file's URL can open it.
Ambassadors
GET /support/api/ambassadors?lat=47.6&lon=-122.3 (or ?location=Seattle, US;
with neither, near the account's address): the nearest 20 Decent owners who offer to show their machine
or help others, with their location, distance and what they offer.
POST /support/api/ambassadors/{ambassador_id}/contact {"subject", "body"}: send them a
message. They get it with the person's email address and reply directly.
Authentication
There are two ways to authenticate. If you are writing a mobile or desktop app, prefer
OAuth2 — your app never touches the user's password. Otherwise you can
send the account's email address together with its encrypted password.
1. Bearer token (OAuth2) — recommended
curl -H "Authorization: Bearer ACCESS_TOKEN" "https://decentespresso.com/support/api/sn"
See OAuth2 browser login for how to obtain the token.
2. Email + password
Call login_test once with the plaintext password to obtain the
encrypted password. Discard the plaintext immediately and store only the encrypted form —
it is what every later call should use.
try it →
GET/support/api/login_test
no login needed
Verifies a set of credentials. Accepts either a plaintext or an already-encrypted password.
| Parameter | | Description |
inemail | required | The account's email address. |
pw | optional | The plaintext password. |
cryptpw | optional | The encrypted password, if you already have it. Supply either pw or cryptpw. |
Returns
0 if the login failed.
- Otherwise the encrypted password, which your app stores and reuses.
Once you hold the encrypted password, any of these three forms authenticates any call on this page:
| Method | How |
| URL parameters | inemail= and cryptpw= appended to the request URL |
| Cookies | an email cookie and a cryptpw cookie |
| HTTP AUTH | standard basic auth: username = email, password = encrypted password |
Examples — first login, with the plaintext password
Recommended only for that first call, whose purpose is to fetch the encrypted password your app will store.
curl "https://decentespresso.com/support/api/login_test?pw=mypassword&inemail=john@somewhere.com"
curl -b "email=john@somewhere.com; pw=mypassword" "https://decentespresso.com/support/api/login_test"
curl -u "john@somewhere.com:mypassword" "https://decentespresso.com/support/api/login_test"
Examples — every later call, with the encrypted password
curl "https://decentespresso.com/support/api/sn_batch_details?sn=9426&cryptpw=11c393223f0d8f7baa6e6853fe600ff8&inemail=john@somewhere.com"
curl -b "email=john@somewhere.com; cryptpw=11c393223f0d8f7baa6e6853fe600ff8" "https://decentespresso.com/support/api/sn_batch_details?sn=9426"
curl -u "john@somewhere.com:11c393223f0d8f7baa6e6853fe600ff8" "https://decentespresso.com/support/api/sn_batch_details?sn=9426"
wget --auth-no-challenge --http-user john@mydomain.com --http-password 44QxPQQCfMiNg "https://decentespresso.com/support/api/sn" -qO-
OAuth2 browser login
Rather than handling the user's Decent password yourself, send them to Decent's own web login and
receive a bearer token in return. This is the standard OAuth 2.0 Authorization Code
flow with PKCE (RFC 7636). The password is only ever typed into the Decent web page —
your app never sees or stores it — and the signed-in account's staff/admin status is captured
server-side at login time.
| Endpoint | Purpose |
/support/oauth2/authorize | The browser login step. Open this in a browser. |
/support/oauth2/token | Exchanges the one-time code for a bearer token. Server-to-server POST. |
Before you start — register your app with Decent
Send us your app details through
the Contact form (pre-filled — click here)
and include your app name, the client_id you would like, and the exact
redirect_uri values your app will use. A Decent admin registers it, after which the flow
below works for your app.
A mobile app registers a custom URL scheme; a web or desktop app registers an https URL it controls.
The redirect_uri must match exactly. (Decent's own apps are built in — e.g. the
dcamp app, client_id=dcamp-ios / redirect_uri=dcamp://auth.)
- Generate the PKCE pair.
Generate a random
code_verifier of 43–128 unreserved characters, then compute
code_challenge = base64url( sha256( code_verifier ) ) with the base64url padding stripped.
- Open the authorize URL in the system browser (or an in-app browser tab).
https://decentespresso.com/support/oauth2/authorize?client_id=YOUR_CLIENT&redirect_uri=YOUR_REDIRECT&state=RANDOM&code_challenge=CHALLENGE&code_challenge_method=S256
- If the browser already has a signed-in Decent
/support session cookie, the user is recognised immediately — one tap, no password.
- Otherwise Decent shows its own email/password form and the user signs in there.
- On success the browser is redirected to
YOUR_REDIRECT?code=ONE_TIME_CODE&state=RANDOM.
Check that the returned state matches what you sent, then read the code.
- Exchange the code for a token.
curl -X POST "https://decentespresso.com/support/oauth2/token" \
-d grant_type=authorization_code \
-d code=ONE_TIME_CODE \
-d code_verifier=YOUR_VERIFIER \
-d redirect_uri=YOUR_REDIRECT \
-d client_id=YOUR_CLIENT \
-d device_id=OPTIONAL_DEVICE_ID
- Call the API with the token.
Send it as an HTTP
Authorization: Bearer header on any Decent API call on this page,
in place of the email + password or HTTP AUTH.
curl -H "Authorization: Bearer ACCESS_TOKEN" "https://decentespresso.com/support/api/emails"
curl -H "Authorization: Bearer ACCESS_TOKEN" "https://decentespresso.com/support/api/sn"
- The same header also works with the Decent Community (dcamp) API at
/support/dcamp/api.
- Tokens are long-lived — store the token, not the password. To revoke one, call the dcamp
API's
token_revoke action with the token.
Notes
- Only
code_challenge_method=S256 is supported; plain PKCE is not accepted.
- The
redirect_uri must exactly match the one registered for your client_id.
- Admin status is decided inside the browser session at login (it requires Decent's emailed
second-factor admin cookie), so a token can carry admin rights without your app ever holding an
admin secret.
Authenticated redirect
Hand the user a web-browser URL that is already logged in, so your app can open a page on
decentespresso.com (e.g. /dcamp) without a second login. Your app calls this
while authenticated; it returns a one-time URL that, when opened, sets the member session cookies and
lands on the destination page. No credentials ever travel in the URL — only an opaque token that
is consumed on first use and expires in ~2 minutes.
GET/support/api/authenticated_redirect
login required
Returns a single-use /redir_auth?auth=… URL for the authenticated user.
| Parameter | | Description |
dest | required | The local path to land on, e.g. /dcamp. Any scheme/host is stripped, so the redirect can never leave decentespresso.com. |
Returns
{"ok":true,"url":"https://decentespresso.com/redir_auth?auth=<token>","expires_in":120}
- Open
url in a browser: it sets the member session cookies (single use, IP recorded, ~120 s TTL) and 302-redirects to dest. Errors: 401 not authenticated, 400 missing dest.
curl -H "Authorization: Bearer $TOKEN" \
"https://decentespresso.com/support/api/authenticated_redirect?dest=/dcamp"
# => {"ok":true,"url":"https://decentespresso.com/redir_auth?auth=6bd2…","expires_in":120}
# open that url in the user's browser -> lands on /dcamp, already logged in
Account & serial numbers
try it →
GET/support/api/sn
login required
Lists the serial numbers of everything this account owns. No parameters are needed beyond the login.
| Parameter | | Description |
withskus=1 | optional | Return sn sku on each line instead of the serial number alone. try it |
onlyespressomachines=1 | optional | Return serial numbers only for espresso machines. try it |
Returns
- A carriage-return separated list of serial numbers, one per line.
Shot history
Every shot uploaded from your machine is stored under that machine's serial number, in your
account. You can list them, pull back the exact document that was stored, chart several against
each other, and throw away the ones you would rather not keep.
Everything in this section is addressed by the machine's serial number
(sn=), which you get from /support/api/sn,
and every call is refused unless the signed-in account owns that serial. Shots themselves are
decaid ShotRecord JSON — the format the Decent app writes.
There are no try it links in this section: every call needs a serial number, and one
that is not yours answers 403.
| Status | Meaning |
200 | Success. The body is JSON with "ok":true, except shot_get, which returns the shot document itself. |
400 | A required parameter is missing or unusable. {"ok":false,"error":"sn required"} |
401 | Not signed in. {"ok":false,"error":"authentication required"} |
403 | Signed in, but this account does not own that serial number. {"ok":false,"error":"not your machine"} |
404 | No such shot, or no uploaded data for that machine. |
Uploading
POST/support/api/shot_upload
login required
Stores one shot. POST the decaid ShotRecord as a UTF-8 JSON request body —
there is no sn= parameter, because the serial number is read from
machine.serialNumber inside the document itself.
The profile is split out of the upload and versioned separately, so uploading a hundred shots
of one unchanged profile stores that profile once. What the shot keeps is a
profile_ref; shot_get puts the full profile back before
returning the document.
curl -X POST -H "Content-Type: application/json" \
-H "Authorization: Bearer ACCESS_TOKEN" \
--data-binary @myshot.json \
"https://decentespresso.com/support/api/shot_upload"
gzip is preferred. A shot document is typically ~340 KB of JSON, and uploads
are transfer-bound rather than server-bound, so compressing the body cuts the upload roughly
8×. If you send Content-Encoding: gzip, the server inflates the body before
parsing it. Keep Content-Type: application/json — it still describes the
decompressed content. A body that cannot be inflated returns 400. Plain
(uncompressed) JSON is still accepted, so this is safe to add unconditionally.
gzip -c myshot.json > myshot.json.gz
curl -X POST -H "Content-Type: application/json" \
-H "Content-Encoding: gzip" \
-H "Authorization: Bearer ACCESS_TOKEN" \
--data-binary @myshot.json.gz \
"https://decentespresso.com/support/api/shot_upload"
Shots are keyed by the id in the document. Re-posting a shot whose
id already exists is, by default, a no-op — the stored copy
is left untouched and the response carries "stored":false,"duplicate":true.
To overwrite an already-stored shot — for example after the user edited it in
decaid and added bean or roaster metadata — add ?replace=1:
curl -X POST -H "Content-Type: application/json" \
-H "Authorization: Bearer ACCESS_TOKEN" \
--data-binary @myshot.json \
"https://decentespresso.com/support/api/shot_upload?replace=1"
A replace rewrites the shot document, its profile_ref and the derived
summary, but preserves the owner’s trash and public-share state — a
shot you had shared stays shared, and a shot you had deleted stays deleted.
Returns
{"ok":true,"stored":true,"id":"…","profile_ref":"…","family":"…","origin":{…}} when a new shot was stored.
"stored":true,"replaced":true when ?replace=1 overwrote an existing shot.
"stored":false,"duplicate":true when the shot id already existed and replace was not set (nothing changed).
profile_ref is family@hash — the profile lineage, and the exact version this shot used.
origin.kind is declared when the profile named its own parent,
inferred when it was matched to a profile shipped with the app (with
origin.confidence between 0 and 1), or none when its ancestry is unknown.
Errors
400 for an empty body, invalid JSON, a body sent with
Content-Encoding: gzip that could not be decompressed, or a document with no
machine.serialNumber, no workflow.profile, or no shot id.
403 machine serial not found in your account.
POST/support/api/steam_upload
login required
Stores one steaming event: POST a decaid SteamRecord as a UTF-8 JSON request body.
Same rules as shot_upload — the serial number comes from
machine.serialNumber in the document.
Steams are kept for machine health rather than for taste: a boiler that is scaling up starts to
hunt, and that oscillation shows in the temperature trace long before the steam goes weak. See
steam_health.
Returns
{"ok":true,"stored":true,"id":"…","scored":true}
scored is false when the record was stored but held too little
temperature data to measure oscillation from.
Reading
GET/support/api/shots
login required
One page of shot summaries for a machine, filtered and sorted. This reads only the derived
summary rows, never the shot documents, so a 50-row page costs kilobytes rather than megabytes.
| Parameter | | Description |
sn | required | Serial number of the machine. |
profile | optional | Exact profile family (a lineage, not one version). |
bean | optional | Exact coffee name. |
roaster | optional | Exact roaster name. |
grinder | optional | Exact grinder model. |
flag | optional | Keep only shots carrying this flag: channel, fast, stalled or short. |
from, to | optional | Unix time (seconds since 1970) bounds on when the shot was pulled. |
q | optional | Substring search across profile title, coffee name, roaster and notes. |
sort | optional | One of shot_ts (default), duration, yield, ratio, enjoyment, peak_pressure, peak_flow, mean_flow, avg_gps, resistance, temp_mean, profile_title, coffee_name. Anything else falls back to shot_ts. |
dir | optional | asc or desc. Default desc, newest first. |
limit | optional | Rows per page. Default 200, maximum 1000. |
offset | optional | Skip this many rows, for paging. Default 0. |
preview=0 | optional | Leave the sparkline curve out of each row. Default is to include it. |
Returns
{"ok":true,"sn":"…","total":N,"limit":N,"offset":N,"shots":[…]}
total counts every shot matching the filter, not just this page — page with offset until you have them all.
- Any measurement that was not recorded comes back as
null rather than 0.
Fields on each shot
| Field | Meaning |
id | Shot id. Feed it to shot_get, curves, siblings and shot_trash. |
ts | Unix time the shot was pulled. |
family, profile | Profile lineage, and the title of the version used. |
bean, roaster, roastDate, roastLevel | What was in the basket, as entered in the app. |
grinder, grind | Grinder model and setting. |
dose, yield, ratio, dur | Grams in, grams out, brew ratio, seconds. |
pi, firstDrop, pourTime | End of preinfusion, first drop in the cup, and time spent pouring — all in seconds. |
peakP, peakF, meanFlow, gps | Peak pressure (bar), peak and mean flow (ml/s), and average grams per second. |
tempMean, tempSag | Mean basket temperature, and how far it sagged under the pour. |
resistance | Puck resistance, from pressure against flow. |
adhP, adhF | How closely the shot tracked the profile's pressure and flow targets. |
tds, ey, enjoyment, notes | Whatever the barista recorded afterwards. |
flags | Array of anomalies detected in the trace: channel, fast, stalled, short. Empty for a clean shot. |
preview | The sparkline curve. See below. |
Decoding preview
40 evenly spaced samples of each of four channels — pressure, flow, weight, temperature,
in that order — as signed 16-bit little-endian integers, base64 encoded. Divide by 100 for
pressure and flow, by 10 for weight and temperature. In a browser that is
new Int16Array(bytes.buffer) and nothing else; the whole curve costs about 430
characters, which is what makes a 50-row list with real sparklines affordable.
Flags are uncalibrated
The channel flag in particular is reasoned from the physics rather than fitted to
labelled shots, and is deliberately conservative: it misses more channelling than it invents.
Treat all four as hints worth a second look, not as verdicts.
GET/support/api/facets
login required
The filter vocabulary for one machine: every distinct profile, bean and grinder it has seen,
with counts, plus the date range and a shots-per-day histogram. One round trip, so a UI can
build its whole filter bar without reading a single shot.
| Parameter | | Description |
sn | required | Serial number of the machine. |
Returns
total, and first / last: the Unix times of the oldest and newest shot.
profiles: [{"family":…,"title":…,"count":N}]. Pass a family back as shots?profile=.
beans: [{"name":…,"roaster":…,"count":N}].
grinders: [{"model":…,"count":N}].
flags: an object of flag name to count.
days: [[day,count],…] for a calendar heat map. day is
whole days since 1970, so multiply by 86400 for a Unix time.
GET/support/api/shot_get
login required
One stored shot, returned as the complete decaid ShotRecord document — the
full sample-by-sample trace, not a summary. The profile is re-inlined into
workflow.profile on the way out, so what you get back is what was uploaded.
| Parameter | | Description |
sn | required | Serial number of the machine. |
id | required | Shot id, from shots. |
Returns
- The shot document itself. This is the one endpoint here whose success body is not
wrapped in
{"ok":true,…} — check the HTTP status, not the body.
404 if there is no such shot, or if it is in the trash.
GET/support/api/curves
login required
Several shots resampled onto one shared time grid, plus the median and the p25–p75 band
across them for each channel. This is what an overlay chart wants: percentiles only mean
anything on a common grid, and computing them here costs about 2 KB per shot instead of
the ~55 KB a document would.
| Parameter | | Description |
sn | required | Serial number of the machine. |
ids | required | Comma-separated shot ids. Anything past the first 200 is ignored. |
step | optional | Grid spacing in seconds. Default 0.25. |
points | optional | Maximum grid points. Default 240, minimum 20. If the shots are too long for step to fit, step is widened to fit instead. |
channels | optional | Comma-separated, from pressure, flow, weight, gflow, temperature. Default pressure,flow,weight — temperature is off because it is a third of the payload. |
Returns
grid: the time axis, in seconds, that every series shares.
series: [{"id":…,"duration":…,"pressure":[…],…}], one array per channel, aligned to grid. Values are null past the end of that shot, so a chart can simply stop drawing.
stats: {"pressure":{"median":[…],"p25":[…],"p75":[…]},…}, also aligned to grid.
count and mincover: how many shots were usable, and how many must still have data at a grid point for statistics to be computed there. Past that point the percentiles are null — beyond the shortest shots, a median would only describe the slow ones.
step and channels: what was actually used, which may not be what you asked for.
This one is expensive
Every id costs a full document read and parse. A handful is quick; 200 is genuinely slow.
GET/support/api/siblings
login required
The shots worth drawing behind one shot: the most recent others on the same profile family,
narrowed to the same coffee when one was recorded. Hand the ids straight to
curves to draw them as ghost traces.
| Parameter | | Description |
sn | required | Serial number of the machine. |
id | required | The shot to find siblings of. |
limit | optional | How many ids to return. Default 20, maximum 200. |
match | optional | bean (default) or profile. |
Returns
ids: sibling shot ids, newest first. The shot you asked about is not among them.
family, title, bean: what that shot was, so you can label the comparison.
matched: what was actually used. Asking for bean on a shot with no
coffee recorded would silently compare it against every other bean-less shot, so it falls back
to profile and says so here.
available_profile and available_bean: how many siblings exist under
each rule, for a "compare against N shots" control.
GET/support/api/profile_diff
login required
What changed between the profile versions two shots used. Because every upload versions its
profile, two shots months apart can be compared setting by setting.
| Parameter | | Description |
sn | required | Serial number of the machine. |
a, b | required | The two shot ids to compare. |
Returns
same: true when both shots used the identical profile version.
changes: [{"path":…,"a":…,"b":…,"kind":"changed"|"added"|"removed"}].
ref_a / ref_b, title_a / title_b, family_a / family_b: which versions were compared.
note: a sentence for the reader — including a warning when the two are
unrelated profiles rather than two versions of one, where a long list of differences means nothing.
Deleting
POST/support/api/shot_trash
login required
Throw shots away, in two stages. Trashing hides them from every other endpoint on this page but
keeps the data; purging deletes it and reclaims the disk space. Nothing is destroyed until you
purge, so a mistaken trash is always recoverable.
This is a POST endpoint: a GET would let a link or a browser prefetch destroy someone's
history. A GET of trash, restore or purge answers
405. The two read-only actions, list and count, also
answer GET.
| Parameter | | Description |
sn | required | Serial number of the machine. |
action | required | trash, restore, list, count or purge. |
ids | optional | Comma-separated shot ids, for trash and restore. A restore with no ids restores the whole trash. |
profile | optional | A profile family. With trash, bins every shot on that profile; with count, says how many that would be. |
| Action | Does | Returns |
trash | Hides the named shots, or the whole profile family. | trashed, ids, remaining, in_trash |
restore | Brings shots back out of the trash. | restored, in_trash |
list | What is in the trash and what it costs. | count, bytes, rows of {"id","ts","deleted_at"} |
count | How many shots a profile family holds — ask before offering to bin it. | count |
purge | Permanently deletes everything in the trash and compacts the store. | purged, bytes_before, bytes_after, bytes_freed |
curl -X POST -H "Authorization: Bearer ACCESS_TOKEN" \
"https://decentespresso.com/support/api/shot_trash?sn=9426&action=trash&ids=abc,def"
purge cannot be undone
Trashed shots are gone for good once purged, and Decent keeps no second copy. Show your user
what list returns, and confirm, before you call it.
Downloading all of it
GET/support/api/shot_export
bearer token only
Your shot history as SQLite files, rather than a shot at a time. Use this to keep your own
copy, to move your history onto your own machine, or to query it with anything that speaks
SQL.
This endpoint takes an OAuth2 bearer token and nothing else
Unlike everything else on this page, email + encrypted password will not authenticate here.
See OAuth2 browser login.
| Parameter | | Description |
what | optional | manifest (the default), db or myprofiles. |
sn | required | For db and myprofiles: which machine. |
userid | optional | Defaults to the account the token belongs to. Naming a different one is a Decent-admin action. |
what= | Returns |
manifest | JSON: your email and name, and a machines array of {"sn","present","bytes","shots","last"}. Start here — it tells you which of your machines actually have uploaded shots, and how big each one is. |
db | That machine's SQLite database, as application/octet-stream. Contains the full shot documents. Taken with SQLite's own online backup, so it is a consistent snapshot even while the server is writing. |
myprofiles | A second, much smaller SQLite database holding just the profile versions that machine used. |
Why there are two files
A stored shot keeps its profile only as a profile_ref, so db on its own
has the traces but not the recipes. myprofiles is the other half: join
shots.profile_ref to profiles.profile_ref and you have the whole
history, self-contained. It is small — a machine that has pulled thousands of shots
typically references a few dozen profile versions, a few hundred KB in total.
TOKEN=ACCESS_TOKEN
BASE=https://decentespresso.com/support/api/shot_export
# 1. which machines do I have, and how big are they?
curl -H "Authorization: Bearer $TOKEN" "$BASE"
# 2. the shots, and 3. the profiles they refer to
curl -H "Authorization: Bearer $TOKEN" -o 9426.db "$BASE?what=db&sn=9426"
curl -H "Authorization: Bearer $TOKEN" -o profiles.db "$BASE?what=myprofiles&sn=9426"
# 4. every shot you ever pulled, oldest first
sqlite3 9426.db "select id, datetime(shot_ts,'unixepoch') from shots order by shot_ts"
Errors
401 if the bearer token is missing, unknown or revoked.
403 for a serial number you do not own, or for another account's userid.
404 if that machine has never uploaded a shot.
One field to ignore
The manifest's profilesBytes measures Decent's whole-server profile archive, which
is a separate admin-only download and is not what myprofiles gives you.
It is not a useful number for planning your own download; the per-machine bytes
figures are.
App logs
The Decent app (and other apps that run on a machine) can upload their own runtime log
files here, so support can see what a given machine has been doing when diagnosing a
problem. Logs are stored per serial number, one row per log line, and are kept for
30 days. You can read your own machine's logs in the browser from
Your Espresso Machines — an App logs link
appears on a machine that has uploaded any (with per-app filtering, text search, and a
.txt download).
POST/support/api/applog_upload
login required
Stores a batch of log lines for one machine. POST a UTF-8 JSON request body. Uploads are
gated by machine ownership, exactly like shot_upload: the account
must own the serial number given in sn.
| field | | |
sn | required | Serial number of the machine the logs came from. |
log | required | The log text, one line per log entry. Each line is expected to start with a
YYYY-MM-DD HH:MM:SS.mmm LEVEL: prefix (the format the Decent app writes); the
timestamp of each line is parsed from that prefix, and a line without one inherits the
timestamp of the line above it. Local time. |
app | optional | Name of the app that produced the logs, e.g. de1app. Stored per
line so logs from different apps on the same machine can be told apart and filtered. |
appVersion | optional | Version of that app. |
firmwareVersion | optional | Machine firmware version, for context. |
uploadedAt, fromTs, toTs | optional | Unix times (seconds) describing the upload and the span it covers. Informational. |
Keep each request under about 1 MB. To send more than that, split the log across
several requests (oldest first) — the Decent app uploads once an hour and, on a large
backlog, sends it a chunk at a time.
curl -X POST -H "Content-Type: application/json" \
-H "Authorization: Bearer ACCESS_TOKEN" \
--data-binary @applog.json \
"https://decentespresso.com/support/api/applog_upload"
# applog.json
{
"app": "de1app",
"appVersion": "1.46.1",
"sn": "12345",
"firmwareVersion": "...",
"uploadedAt": 1787821743,
"fromTs": 1787815800,
"toTs": 1787819400,
"log": "2026-08-27 10:00:00.100 NOTICE: build-info: version v1.46.1\n2026-08-27 10:30:00.100 ERROR: BLE connect failed\n"
}
Returns
{"ok":true,"stored":N,"sn":"…"} — stored is the number of log lines saved.
Errors
400 for an empty body, invalid JSON, or a missing sn.
403 machine serial not found in your account.
Machine health & fleet comparison
Beta — these two are not finished
Both endpoints work and are stable in shape, but neither number behind them has been calibrated:
the steam-oscillation detector has never been checked against a machine known to be scaled, and the
fleet aggregate is empty for any profile too few people use. The matching views are still switched
off in the customer web UI. Read the trends, do not quote the values.
GET/support/api/steam_health
login required
beta
A machine's steam-oscillation history and where it is heading. As a boiler scales up its
temperature control starts to hunt, and that oscillation is measurable in the steam trace well
before anyone notices weak steam. Needs steam records to have been uploaded by
steam_upload.
| Parameter | | Description |
sn | required | Serial number of the machine. |
limit | optional | How many scored events to return, oldest first. Default 400. |
backfill=1 | optional | Score any stored steam records that have no score yet before answering. |
Returns
total and scored: steam records stored, and how many yielded a score.
series: [{"id","ts","duration","peak","oscillation","sd","band","hz","samples"}],
oldest first. oscillation is the headline number; sd, band
and hz describe the temperature wobble it came from.
trend: recent against baseline (this machine's own quiet
level), their ratio, the slope_30d per 30 days, the all-time
median, the window_n events in the recent window, and
last_drop — a sharp fall, which is almost always a descale.
calibrated: always false today. It is in the response so that client
code can start checking it now and quietly stop showing the caveat later.
Compare a machine only against itself
The scale is arbitrary and unfitted, so a ratio of 3 on one machine and a ratio of 3 on another
do not mean the same thing. What is meaningful is one machine's own ratio and
slope_30d rising over time.
GET/support/api/fleet
login required
beta
How everyone else's shots on a profile are distributed, so you can see where yours sit. This is
the only endpoint in this section that takes no serial number: it reads a pre-computed aggregate,
never anyone's shots.
| Parameter | | Description |
family | required | Profile family, exactly as facets or shots spells it. |
model | optional | Restrict to one machine model. Omitted, all models are pooled. |
Returns
stats: [{"metric":…,"machines":N,"shots":N,"p10":…,"p25":…,"p50":…,"p75":…,"p90":…}].
- One row per metric:
duration, ratio, peak_pressure,
mean_flow, yield.
- An empty
stats array is the normal answer for a profile that not enough
people use. Handle it; do not treat it as an error.
What the aggregate holds
No serial numbers, no account ids, and no per-shot rows — only percentiles. A bucket is
published only once at least 5 distinct machines and 10 shots contribute to it, and
is suppressed entirely otherwise, so nothing here can be traced back to one person's machine.
Tech-support email
Access to the Decent Espresso tech support email system.
GET/support/api/email
login required
Sends an email to Decent tech support on behalf of the logged-in account.
| Parameter | | Description |
subject | required | Subject line of the message. |
body | required | Body of the message. |
Returns
try it →
GET/support/api/emails
login required
A JSON document of all emails for this person, sorted most recent first.
| Parameter | | Description |
limit | optional | Maximum number of messages to return. |
offset | optional | Skip this many messages, for paging through results. |
emailid | optional | Return only the one specified email. |
since | optional | Unix time (seconds since 1970). Return only messages created at or after this time. |
before | optional | Unix time (seconds since 1970). Return only messages created at or before this time. |
Returns
0 if the call failed.
- An empty JSON document
[] if there are no emails.
- Otherwise a JSON array of message objects.
Notable fields
| Field | Meaning |
now | Unix time the message was created. Feed the most recent one back as since= on your next call. |
automsg | This was an automatically generated outbound email, not human authored. |
from_user | A Decent employee name. A thumbnail photo is available at
https://decentespresso.com/img/cartoon_from_user_small.png — for example
cartoon_john_small.png. |
Recommended usage
Store the emails you fetch in a local sqlite database. Each time your app shows its "read emails"
page, ask only for messages newer (since=) than the most recent now value
already in your local database.
Decent Community (dcamp) forum
The JSON API behind the Decent Community forum and its iPhone, iPad, Mac and Android
apps: boards, threads, comments, chat, direct messages, search, notifications, bookmarks and your own
forum settings. It acts as your own forum membership: you can read what you're allowed to see, and
post, edit and delete only what you're allowed to in the forum itself. Moderation and Adminland actions
are refused unless the account is a dcamp administrator.
GET/POST/support/dcamp/api
login required
One endpoint for everything: the action parameter says what to do.
(/support/dcamp/api.adp is the same endpoint.)
| Parameter | | Description |
action | required | What to do. The common ones:
bootstrap (who you are, your boards and settings),
projects (boards),
messages (a board's threads: project_id, offset, limit),
message (one thread with its comments: id; optional c = a comment id to open on),
resolve_msg (a thread id from a forum URL: project_id, slug),
comment_one (one comment, with its message_id: id),
search (q),
message_create (project_id, subject, body),
comment_create (message_id, body),
message_update (id, subject, body, category_id; see Editing),
comment_update (id, body) / comment_delete (id),
chat, chat_post,
dm_conversations, dm_thread, dm_send (see below),
activity_feed, notif_poll,
bookmarks_list, bookmark_set,
person (a member's profile: id),
upload (multipart file; returns a URL to use in a post),
token_revoke (sign a token out: token). |
X-Dcamp-Lang | optional | HTTP header: answer, and translate
posts, in this language (e.g. fr). |
Returns
{"ok":true, …}, or {"ok":false, "error":"…"}.
- Times such as
created_at are Unix epoch seconds (integers), not formatted date strings.
- Yes/no fields such as
mine, is_admin and has_more are 0 or 1, not JSON true/false.
Logging in
Get a token from POST /support/api/login (email + password) or the
OAuth2 browser login, and send it on every call as
Authorization: Bearer ….
- Tokens are long-lived. Store the token, not the password, and log in again only if a call answers
Please log in.
- Call
bootstrap first. It returns your own member id (me.id), whether you are an
admin (is_admin), whether you may post (can_post), and the boards you can see.
action=token_revoke with token=… signs that token out.
curl -H "Authorization: Bearer $TOKEN" "https://decentespresso.com/support/dcamp/api?action=bootstrap"
curl -H "Authorization: Bearer $TOKEN" "https://decentespresso.com/support/dcamp/api?action=search&q=steam+wand"
Sending parameters: GET in the URL, POST in the body
On a GET, put action and the other parameters in the query string. On a POST, put
all of them in the request body, action included: when there is a body, only the body is
read, and a query string is ignored. Forgetting this gives {"ok":false,"error":"unknown action: "},
with the action name blank. That error means "no action arrived", not "this endpoint is broken".
curl -H "Authorization: Bearer $TOKEN" -d action=comment_create -d message_id=11978 \
--data-urlencode "body=<p>Thanks, that fixed it.</p><p>Second paragraph.</p>" https://decentespresso.com/support/dcamp/api
Bodies are HTML
Post bodies are HTML both ways: send HTML, and strip the tags when you want plain text back. Escape
<, > and & in anything that should show literally, such as
pasted code: <build> shows as <build>, but a bare
<build> is read as an HTML tag and disappears.
- Paragraphs: dcamp, like Basecamp, puts no space around a paragraph. The gap you see between
paragraphs is an empty line,
<p><br></p>. When a thread or comment holds
<p> paragraphs (or lists) right next to each other, the server adds that empty line
between them, so plain <p>One</p><p>Two</p> shows as two paragraphs. Posts
written in the forum use <div>One<br><br>Two</div>, which works too.
- Line breaks: use
<br> for a new line with no gap. Inline tags
(<strong>, <em>, <a>, <code>) work as usual.
- Links: a bare
https://… in the text stays plain text; dcamp does not turn it
into a link. Write <a href="https://…">https://…</a>.
Editing and deleting
Both edit actions replace the whole record. Neither is a patch: there is no way to change one field
and leave the rest.
comment_update takes id and body, both required. The new body
replaces the old one completely. An empty body answers Comment is empty.
message_update (a thread) takes id, subject, body and
category_id. Send all of them, copying the current values (from message) for
anything you are not changing. A field you leave out is saved as empty: sending only id and
body wipes the thread's title and category, and the call still answers
{"ok":true}.
- Both answer
{"ok":true} without showing what was saved. To confirm an edit, read it back:
comment_one (id) for a comment, message (id) for a thread,
and check the subject too.
comment_delete takes id only.
- You can edit or delete only your own posts: someone else's answers
{"ok":false,"error":"not allowed"}, and an id that does not exist answers
{"ok":false,"error":"not found"}.
curl -H "Authorization: Bearer $TOKEN" -d action=comment_update -d id=180543 \
--data-urlencode "body=<p>Corrected text.</p>" https://decentespresso.com/support/dcamp/api
curl -H "Authorization: Bearer $TOKEN" -d action=message_update -d id=12613 \
-d category_id=0 --data-urlencode "subject=This week on Decaid" --data-urlencode "body=<p>Fixed link.</p>" \
https://decentespresso.com/support/dcamp/api
curl -H "Authorization: Bearer $TOKEN" "https://decentespresso.com/support/dcamp/api?action=comment_one&id=180543"
Finding a thread from a forum URL
Forum links look like /dcamp/board-slug/thread-slug, sometimes followed by
/number. That trailing number is a comment id, not a thread id, so passing it to
action=message answers Message not found. Instead:
- Turn the two slugs into a thread id with
resolve_msg (project_id accepts the board slug).
- Or look up the comment with
comment_one and use its comment.message_id.
# https://decentespresso.com/dcamp/problems/pre-infuse-uses-max-flow-rate/180064
curl -H "Authorization: Bearer $TOKEN" \
"https://decentespresso.com/support/dcamp/api?action=resolve_msg&project_id=problems&slug=pre-infuse-uses-max-flow-rate"
→ {"ok":true,"id":11956}
curl -H "Authorization: Bearer $TOKEN" "https://decentespresso.com/support/dcamp/api?action=comment_one&id=180064"
→ {"ok":true,"comment":{"id":180064,"message_id":11956,…}}
# then open the thread, scrolled to that comment:
curl -H "Authorization: Bearer $TOKEN" "https://decentespresso.com/support/dcamp/api?action=message&id=11956&c=180064"
Direct messages
dm_conversations lists your conversations (offset, limit, optional
q to find a person). Each one's id is the conversation id.
dm_thread with id=conversation id returns the newest messages
(limit, default 40). Each message has id, body (HTML),
created_at (epoch seconds), mine (1 if you sent it) and a
sender object. max_id is the newest message id in the whole conversation.
- To page back to older messages while
has_more is 1, call dm_thread again with
bca = the created_at and bid = the id of the oldest message you
already have.
dm_send posts to a conversation: convo = conversation id, body = HTML.
curl -H "Authorization: Bearer $TOKEN" "https://decentespresso.com/support/dcamp/api?action=dm_conversations&limit=20"
curl -H "Authorization: Bearer $TOKEN" "https://decentespresso.com/support/dcamp/api?action=dm_thread&id=377"
curl -H "Authorization: Bearer $TOKEN" "https://decentespresso.com/support/dcamp/api?action=dm_thread&id=377&bca=1793640815&bid=234755"
curl -H "Authorization: Bearer $TOKEN" -d action=dm_send -d convo=377 \
--data-urlencode "body=<p>See you then.</p>" https://decentespresso.com/support/dcamp/api
Uploading files
Send a multipart POST with the file in a field called file, and action=upload as
a form field in the same body. A ?action=upload in the URL alone gives
unknown action: . The answer holds a url: put it in a post's HTML, e.g.
<img src="…"> or a link.
- Allowed types: images (
.jpg .jpeg .png .gif .webp .bmp .heic .heif), video and audio
(.mp4 .mov .webm .m4v .mp3 .m4a .wav .ogg), and .pdf .txt .log .csv .zip .xml .json.
- Anything else, including source files such as
.sh or .py, answers
That file type isn't allowed. Zip them, or rename a script to .txt.
- The returned URL is public: anyone with the link can open it.
curl -H "Authorization: Bearer $TOKEN" -F action=upload -F "file=@photo.jpg" https://decentespresso.com/support/dcamp/api
→ {"ok":true,"url":"/support/dcamp/attachments/u1793807967/photo.jpg","is_image":1,"filename":"photo.jpg",…}
Permanent cookies
Server-side storage of key/value pairs, stored for the currently logged-in user.
try it →
GET/support/api/permacookie_set
login required
Stores a given key/value pair.
| Parameter | | Description |
key | required | Maximum 255 UTF-8 characters. |
value | required | Maximum 65,535 bytes (64 KB), binary-safe. An empty value= is legal and stores a blank value. |
Returns
1 on success, 0 on failure.
try it →
GET/support/api/permacookie_get
login required
Returns the value stored for a given key.
| Parameter | | Description |
key | required | The key to read. |
Returns
- The stored value.
- An empty string if the key does not exist, if the stored value is itself an empty string, or if
key= was not provided.
try it →
GET/support/api/permacookie_clear
login required
Erases a given key and its value. Succeeds even if the key does not exist.
| Parameter | | Description |
key | required | The key to erase. |
Returns
1 on success, 0 on failure.
Products & factory data
What the Decent factory is making, and metadata on all their products.
try it →
GET/support/api/sn_batch_details
login required
Returns a JSON document of the build details for a single serial number — a DE1 or Bengle
espresso machine, a Half Decent Scale, a rinser: anything Decent builds that carries a serial number.
| Parameter | | Description |
sn | required | The serial number to look up. |
Returns
- No result if no machine was built with that serial number.
try it →
GET/support/api/sku_details
login required
Returns a JSON document of the details for one product (SKU) at Decent Espresso. Espresso machines carry more metadata than other products.
| Parameter | | Description |
sku | required | The SKU to look up. |
Returns
- No result if that SKU does not exist.
GET/js/data/decent_products.js
no login needed
A JavaScript file that defines a global variable holding all Decent product data.
open it →
GET/js/data/decent_products.json
no login needed
The same all-products data as a JSON document.
open it →
Questions, or something missing from this page? Get in touch.
|