Decent API

accueil


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.

Shopping: account, address, checkout

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.

  1. 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.
  2. 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).
  3. 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).
  4. 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.
  5. 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.
  6. 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.
  7. 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
inemailrequiredThe account's email address.
pwoptionalThe plaintext password.
cryptpwoptionalThe 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:

MethodHow
URL parametersinemail= and cryptpw= appended to the request URL
Cookiesan email cookie and a cryptpw cookie
HTTP AUTHstandard 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.

EndpointPurpose
/support/oauth2/authorizeThe browser login step. Open this in a browser.
/support/oauth2/tokenExchanges 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.)
  1. 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.
  2. 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.
  3. 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
    • The code is single-use and expires 5 minutes after it is issued.
    • Success returns JSON:
      {"ok":true,"access_token":"…","token_type":"bearer","is_admin":0}
    • is_admin is 1 when the signed-in account is a verified Decent admin.
    • Failure returns {"error":"invalid_grant"} (bad, expired or reused code, or a failed PKCE check) or {"error":"unsupported_grant_type"}.
  4. 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
destrequiredThe 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=1optionalReturn sn sku on each line instead of the serial number alone. try it
onlyespressomachines=1optionalReturn 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.

StatusMeaning
200Success. The body is JSON with "ok":true, except shot_get, which returns the shot document itself.
400A required parameter is missing or unusable. {"ok":false,"error":"sn required"}
401Not signed in. {"ok":false,"error":"authentication required"}
403Signed in, but this account does not own that serial number. {"ok":false,"error":"not your machine"}
404No 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
snrequiredSerial number of the machine.
profileoptionalExact profile family (a lineage, not one version).
beanoptionalExact coffee name.
roasteroptionalExact roaster name.
grinderoptionalExact grinder model.
flagoptionalKeep only shots carrying this flag: channel, fast, stalled or short.
from, tooptionalUnix time (seconds since 1970) bounds on when the shot was pulled.
qoptionalSubstring search across profile title, coffee name, roaster and notes.
sortoptionalOne 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.
diroptionalasc or desc. Default desc, newest first.
limitoptionalRows per page. Default 200, maximum 1000.
offsetoptionalSkip this many rows, for paging. Default 0.
preview=0optionalLeave 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
FieldMeaning
idShot id. Feed it to shot_get, curves, siblings and shot_trash.
tsUnix time the shot was pulled.
family, profileProfile lineage, and the title of the version used.
bean, roaster, roastDate, roastLevelWhat was in the basket, as entered in the app.
grinder, grindGrinder model and setting.
dose, yield, ratio, durGrams in, grams out, brew ratio, seconds.
pi, firstDrop, pourTimeEnd of preinfusion, first drop in the cup, and time spent pouring — all in seconds.
peakP, peakF, meanFlow, gpsPeak pressure (bar), peak and mean flow (ml/s), and average grams per second.
tempMean, tempSagMean basket temperature, and how far it sagged under the pour.
resistancePuck resistance, from pressure against flow.
adhP, adhFHow closely the shot tracked the profile's pressure and flow targets.
tds, ey, enjoyment, notesWhatever the barista recorded afterwards.
flagsArray of anomalies detected in the trace: channel, fast, stalled, short. Empty for a clean shot.
previewThe 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
snrequiredSerial 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
snrequiredSerial number of the machine.
idrequiredShot 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
snrequiredSerial number of the machine.
idsrequiredComma-separated shot ids. Anything past the first 200 is ignored.
stepoptionalGrid spacing in seconds. Default 0.25.
pointsoptionalMaximum grid points. Default 240, minimum 20. If the shots are too long for step to fit, step is widened to fit instead.
channelsoptionalComma-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
snrequiredSerial number of the machine.
idrequiredThe shot to find siblings of.
limitoptionalHow many ids to return. Default 20, maximum 200.
matchoptionalbean (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
snrequiredSerial number of the machine.
a, brequiredThe 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
snrequiredSerial number of the machine.
actionrequiredtrash, restore, list, count or purge.
idsoptionalComma-separated shot ids, for trash and restore. A restore with no ids restores the whole trash.
profileoptionalA profile family. With trash, bins every shot on that profile; with count, says how many that would be.
ActionDoesReturns
trashHides the named shots, or the whole profile family.trashed, ids, remaining, in_trash
restoreBrings shots back out of the trash.restored, in_trash
listWhat is in the trash and what it costs.count, bytes, rows of {"id","ts","deleted_at"}
countHow many shots a profile family holds — ask before offering to bin it.count
purgePermanently 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
whatoptionalmanifest (the default), db or myprofiles.
snrequiredFor db and myprofiles: which machine.
useridoptionalDefaults to the account the token belongs to. Naming a different one is a Decent-admin action.
what=Returns
manifestJSON: 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.
dbThat 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.
myprofilesA 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
snrequiredSerial number of the machine the logs came from.
logrequiredThe 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.
appoptionalName 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.
appVersionoptionalVersion of that app.
firmwareVersionoptionalMachine firmware version, for context.
uploadedAt, fromTs, toTsoptionalUnix 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
snrequiredSerial number of the machine.
limitoptionalHow many scored events to return, oldest first. Default 400.
backfill=1optionalScore 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
familyrequiredProfile family, exactly as facets or shots spells it.
modeloptionalRestrict 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
subjectrequiredSubject line of the message.
bodyrequiredBody of the message.
Returns
  • 0 if the send failed.
try it → GET/support/api/emails login required

A JSON document of all emails for this person, sorted most recent first.

Parameter Description
limitoptionalMaximum number of messages to return.
offsetoptionalSkip this many messages, for paging through results.
emailidoptionalReturn only the one specified email.
sinceoptionalUnix time (seconds since 1970). Return only messages created at or after this time.
beforeoptionalUnix 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
FieldMeaning
nowUnix time the message was created. Feed the most recent one back as since= on your next call.
automsgThis was an automatically generated outbound email, not human authored.
from_userA 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
actionrequiredWhat 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-LangoptionalHTTP 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: &lt;build&gt; 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
keyrequiredMaximum 255 UTF-8 characters.
valuerequiredMaximum 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
keyrequiredThe 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
keyrequiredThe 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
snrequiredThe 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
skurequiredThe 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.