dashfront/.agents/skills/backend/SKILL.md

name, description

name	description
backend	Reference documentation for backend service. Use this skill whenever working with backend APIs.

Dash API Routes Overview (All)

Overview of all 242 API endpoints across all modules.

Notation

Types: str string, int integer, num number, bool boolean; T[] array; ? optional. Params: path values first, then query: and body: (body? = optional body). Responses: status code + JSON shape; Tn refers to a reusable type below.

Reusable types

• T1 = { order: T2 }
• T2 = { id: int, number: str, type: str, entityId: int|null, date: str, lines: T29[], createdAt?: str, shipping?: T37|null, shippings?: T37[], payment?: T43|null, payments?: T43[], paid?: bool, shipped?: bool, delivered?: bool, orderTotal?: num, paidTotal?: num, orderedQuantity?: num, shippedQuantity?: num, shipments?: T5[], files?: T15[] }
• T3 = { article: T4 }
• T4 = { id: int, sku: str, name: str, slug: str, desc: str|null, seo: str|null, track_stock: bool, unitamount: num|null, weight: num|null, unit: T40, brand: T38|null, categoryIds: int[], photos: T35[], eans: str[], prices: T47[], suppliers: T17[] }
• T5 = { id: int, number: str, type: str, date: str, lines: T29[], shippings: T37[], entityId?: int|null, externalNumber?: str|null, createdAt?: str|null, lineCount?: int, packageCount?: int, files?: T15[] }
• T6 = { delivery: T7 }
• T7 = { id: int, number: str, type: str, supplierId: int|null, date: str, lines: T29[], files: T15[], externalNumber?: str|null, createdAt?: str, ledger?: T51 }
• T8 = { quote: T9 }
• T9 = { id: int, number: str, type: str, entityId: int|null, date: str, lines: T29[], createdAt?: str, positions?: int, grossTotal?: num, totalQuantity?: num, customerName?: str|null, files?: T15[] }
• T10 = { name: str, path: str, totalSizeBytes: int, timestamp: str|null, manifest?: T11|null }
• T11 = { id: str, timestamp: str, dateKey: str, monthKey: str, dbProvider: str, files: T18, totalSizeBytes: int, durationMs: int }
• T12 = { labeltemplate: T14 }
• T13 = { attachment: T15, fileUrl: str }
• T14 = { id: int, name: str, width: num, height: num, dpi: int, type: str, content: T25, thumb?: str|null }
• T15 = { id: int, manifestId: int, fileId: int, sort: int, hash: str, mimetype: str, name: str, size: int, created?: str, modified?: str, thumbavif?: str|null, thumbx?: int|null, thumby?: int|null, meta?: { [k]: str }|null }
• T16 = { id: int, name: str, pairingpin?: str|null, token?: str|null, pairedAt?: str|null, clientserial?: str|null, rootCategoryId?: int|null, syncRootArticles?: bool, lastseenAt?: str|null, updatedAt?: str|null, categoryIds?: int[] }
• T17 = { id: int, articleId: int, entityId: int, pu: num, sort: int, supplierName?: str|null, sku?: str|null, stock?: num|null, priceId?: int|null, price?: T54|null }
• T18 = { vfs: T52, storage: T52, database: T45 }
• T19 = { id: int, entityId: int, addressType: str, firstName?: str|null, name?: str|null, street?: str|null, streetNumber?: str|null, zip?: str|null, city?: str|null, county?: str|null }
• T20 = { ledger: T21[] }
• T21 = { id: int, manifestarticle_id: int, transaction_type: str, amount: num, transaction_text: str, hash_version: int, prev_hash?: str, sku?: str|null, created_at?: str }
• T22 = { id: int, name: str, sort: int, exclusive: bool, values: T41[], articleCount?: int }
• T23 = { id: int, companyuser_id: int, provider: str, model: str, created_at: str, updated_at: str, state: str, started_by?: integer,null, first_message?: string,null }
• T24 = { id: int, name: str, rootCategoryId: int|null, languageId: int|null, iso639: str|null, taxrate: num, reducedtaxrate: num, taxfreerate: num }
• T25 = { objects: T30[] }
• T26 = { objects: T31[] }
• T27 = { printer: T33 }
• T28 = { entity: T36 }
• T29 = { id: int, sku: str|null, name: str|null, pu: num, amount: num, net: num, rebate: num, taxrate: num, comment: str|null }
• T30 = { id: str, type: str, x: num, y: num, w?: num, h?: num, text?: str, font?: str, fontSize?: num, barcodeFormat?: str }
• T31 = { id: str, type: str, x: num, y: num, w?: num, h?: num, text?: str, font?: str, fontSize?: num, barcodeFormat?: str }
• T32 = { shipping: T37 }
• T33 = { id: int, company_id: int, address: str, type: str, sort: int, model?: str|null, serial?: str|null, desc?: str|null }
• T34 = { amount: num, net: num, taxrate: num, sku?: str|null, name?: str|null, pu?: num, rebate?: num, comment?: str|null }
• T35 = { sort: int, fullHash: str, fullW: int, fullH: int, fullSize: int, thumbW: int, thumbH: int, thumbHash: str }
• T36 = { id: int, customergroupId: int, firstName: str|null, name: str, number: str|null, createdAt: str, updatedAt: str }
• T37 = { id: int, manifestId: int, number: str, type: str, state: str, trackingCode?: str|null, carrier?: str|null }
• T38 = { name: str, id?: int|null, fullHash?: str|null, thumbW?: int|null, thumbH?: int|null, thumbHash?: str|null }
• T39 = { article: T44 }
• T40 = { si: str, basesi: str, basesifactor: num, symbol?: str|null, name?: str|null }
• T41 = { id: int, attributeId: int, value: str, sort: int, articleCount?: int }
• T42 = { id: int, name: str, sort: int, exclusive: bool, articleCount?: int }
• T43 = { id: int, accountId: int, manifestId: int, type: str, amount: num }
• T44 = { id: int, categoryId: int, name: str, sku: str, track_stock: bool }
• T45 = { name: str|null, sizeBytes: int, backedUp: bool, reason?: str|null }
• T46 = { id: int, email: str, selectedCompanyId: int|null, picture?: str }
• T47 = { minmultiplier: num, net: num, taxRate: num, customergroupId: int }
• T48 = { fullHash: str, thumbW: int, thumbH: int, thumbHash: str }
• T49 = { id: int, entityId: int, contactType: str, contact: str }
• T50 = { id: int, name: str, createdAt: str, updatedAt: str }
• T51 = { totalPositions: int, completelyOnLedgerPositions: int }
• T52 = { name: str, sizeBytes: int, sourceExists: bool }
• T53 = { warehouse: T55 }
• T54 = { net: num, taxId: int, taxRate?: num|null }
• T55 = { id: int, name: str, sort: int }
• T56 = { id: int, categoryIds: int[] }

Routes

Section: /.well-known

OAuth 2.0 Authorization Server Metadata (RFC 8414) — GET /.well-known/oauth-authorization-server

none

• Returns: 200

OAuth 2.0 Protected Resource Metadata (RFC 9728) — GET /.well-known/oauth-protected-resource

none

• Returns: 200

Section: /account

List accounts — GET /account

none

• Returns: 200 { accounts: { id: int, companyId: int, type: str, name: str }[] }

Create account — POST /account

• Params: body: { type: str, name: str }
• Returns: 201 { account: { id: int, companyId: int, type: str, name: str } }

Delete account — DELETE /account/{id}

• Params: id: int
• Returns: 204 void

Section: /article

Create article in category — POST /article

• Params: body: { categoryId: int, name: str, desc?: str, seo?: str, track_stock?: bool }
• Returns: 201 T39

Export articles as ZIP — GET /article/export.zip

• Params: query: categoryId?: int
• Returns: 200 zip

Delete article by SKU — DELETE /article/{sku}

• Params: sku: str, query: cascade?: bool
• Returns: 204 void

Get article by SKU — GET /article/{sku}

• Params: sku: str
• Returns: 200 T3

Update article by SKU — PATCH /article/{sku}

• Params: sku: str, body: { name?: str, desc?: str, seo?: str, unitamount?: num, unitSi?: str, track_stock?: bool }
• Returns: 200 T3

Get Stückliste (bundle items) for an article — GET /article/{sku}/articlelist

• Params: sku: str
• Returns: 200 { items: { id: int, articleId: int, sku: str, name: str, count: int, sort: int }[] }

Set Stückliste (bundle items) for an article — PUT /article/{sku}/articlelist

• Params: sku: str, body: { items: { articleId?: int, sku?: str, count?: int, sort?: int }[] }
• Returns: 200 { items: { id: int, articleId: int, sku: str, name: str, count: int, sort: int }[] }

List article attribute values — GET /article/{sku}/attributevalue

• Params: sku: str
• Returns: 200 { attributevalues: { id: int, attributeId: int, attributeName: str, attributeValueId: int, value: str, sort: int, articleId?: int, exclusive?: bool }[] }

Bulk set article attribute values — PUT /article/{sku}/attributevalue

• Params: sku: str, body: int[]
• Returns: 200 { attributevalues: { id: int, attributeId: int, attributeName: str, attributeValueId: int, value: str, sort: int, articleId?: int, exclusive?: bool }[] }

Set or clear article brand by SKU (null to clear) — PUT /article/{sku}/brand

• Params: sku: str, body: { brandId: int|null }
• Returns: 200 T3

Replace article categories by SKU — PUT /article/{sku}/categories

• Params: sku: str, body: { categoryIds: int[] }
• Returns: 200 T3

List child articles of a parent article — GET /article/{sku}/children

• Params: sku: str
• Returns: 200 { children: { id: int, sku: str, name: str, parentsort: int, attributeValueId: int, attributeValue: str }[] }

Create and attach a new child article to a parent article — POST /article/{sku}/children

• Params: sku: str, body: { attributeValueId?: int, value?: str, name?: str }
• Returns: 201 T39

Attach an existing article as a child to a parent article — PUT /article/{sku}/children

• Params: sku: str, body: { sku: str, attributeValueId?: int, value?: str, reparent?: bool }
• Returns: 200 { article: T44, children: { id: int, sku: str, name: str, parentsort: int, attributeValueId: int, attributeValue: str }[] }

Remove a child article from a parent article — DELETE /article/{sku}/children/{childSku}

• Params: sku: str, childSku: str, query: deleteArticle?: bool
• Returns: 200 { success: bool, deleted: bool }

Replace article EANs by SKU — PUT /article/{sku}/eans

• Params: sku: str, body: { eans: str[] }
• Returns: 200 T3

Get article history by SKU — GET /article/{sku}/history

• Params: sku: str, query: limit?: int
• Returns: 200 { history: { id: int, date: str, text: str }[], truncated: bool }

Add article image — POST /article/{sku}/image

• Params: sku: str, image/avif
• Returns: 201 { image: { picId: int, sort: int, full: { w: int, h: int, size: int }, thumb: { w: int, h: int }, hash: str, thumbHash: str } }

Delete article image — DELETE /article/{sku}/image/{fullHash}

• Params: sku: str, fullHash: str
• Returns: 204 void

Reorder article images — PUT /article/{sku}/images/order

• Params: sku: str, body: { fullHashes: str[] }
• Returns: 200 { fullHashes: str[] }

Get options list for an article — GET /article/{sku}/optionslist

• Params: sku: str
• Returns: 200 { options: { id: int, articleId: int, sku: str, name: str, count: int, sort: int, mandated: bool }[] }

Set options list for an article — PUT /article/{sku}/optionslist

• Params: sku: str, body: { options: { articleId?: int, sku?: str, count?: int, sort?: int, mandated?: bool }[] }
• Returns: 200 { options: { id: int, articleId: int, sku: str, name: str, count: int, sort: int, mandated: bool }[] }

Toggle parent mode for an article — POST /article/{sku}/parent

• Params: sku: str, body: { isParent: bool, attributeNameId?: int }
• Returns: 200 T39

Replace POS prices by SKU (net > gross; price=net, tax=taxRate %) — PUT /article/{sku}/prices

• Params: sku: str, body: { prices: { net?: num, gross?: num, price?: num, taxRate?: num, tax?: num, minmultiplier?: num }[] }
• Returns: 200 T3

Print article label — POST /article/{sku}/print

• Params: sku: str, body: { templateId: int, printerId: int, quantity: int }
• Returns: 200 { success: bool }

List article properties — GET /article/{sku}/property

• Params: sku: str
• Returns: 200 { properties: { id: int, propertyId: int, name: str, exclusive: bool, value: str, sort: int, articleId?: int }[] }

Bulk set article properties — PUT /article/{sku}/property

• Params: sku: str, body: { properties: { propertyId: int, value: str, sort?: int }[] }
• Returns: 200 { properties: { id: int, propertyId: int, name: str, exclusive: bool, value: str, sort: int, articleId?: int }[] }

Delete article property — DELETE /article/{sku}/property/{propertyId}

• Params: sku: str, propertyId: int
• Returns: 200 { ok: bool }

List article suppliers — GET /article/{sku}/supplier

• Params: sku: str
• Returns: 200 { suppliers: T17[] }

Assign supplier to article — POST /article/{sku}/supplier

• Params: sku: str, body: { entityId: int, sku?: str|null, pu?: num, stock?: num|null, sort?: int|null, netPrice?: num|null, taxId?: int|null, taxRate?: num|null }
• Returns: 201 { supplier: T17 }

Reorder article suppliers — PUT /article/{sku}/supplier/order

• Params: sku: str, body: { ids: int[] }
• Returns: 200 { ids: int[] }

Remove supplier assignment from article — DELETE /article/{sku}/supplier/{id}

• Params: sku: str, id: int
• Returns: 204 void

Update article supplier assignment — PATCH /article/{sku}/supplier/{id}

• Params: sku: str, id: int, body: { sku?: str|null, pu?: num, stock?: num|null, sort?: int, netPrice?: num|null, taxId?: int|null, taxRate?: num|null }
• Returns: 200 { supplier: T17 }

Set article track_stock flag by SKU — PUT /article/{sku}/track_stock

• Params: sku: str, body: { track_stock: bool }
• Returns: 200 T3

Set article weight by SKU — PUT /article/{sku}/weight

• Params: sku: str, body: { weight: num }
• Returns: 200 T3

Section: /attributename

List attribute names — GET /attributename

none

• Returns: 200 { attributenames: T22[] }

Create attribute name — POST /attributename

• Params: body: { name: str, sort?: int, exclusive?: bool }
• Returns: 201 { attributename: T22 }

Reorder attribute names — PUT /attributename/order

• Params: body: { attributenameIds: int[] }
• Returns: 200 { ok: bool }

List values for an attribute — GET /attributename/{attributeId}/value

• Params: attributeId: int
• Returns: 200 { values: T41[] }

Create value for an attribute — POST /attributename/{attributeId}/value

• Params: attributeId: int, body: { value: str, sort?: int }
• Returns: 201 { attributevalue: T41 }

Reorder values of an attribute — PUT /attributename/{attributeId}/value/order

• Params: attributeId: int, body: { attributevalueIds: int[] }
• Returns: 200 { ok: bool }

Delete attribute name — DELETE /attributename/{id}

• Params: id: int
• Returns: 200 { ok: bool }

Update attribute name — PATCH /attributename/{id}

• Params: id: int, body: { name?: str, sort?: int, exclusive?: bool }
• Returns: 200 { attributename: T22 }

Section: /attributevalue

Delete attribute value — DELETE /attributevalue/{id}

• Params: id: int
• Returns: 200 { ok: bool }

Update attribute value — PATCH /attributevalue/{id}

• Params: id: int, body: { value?: str, sort?: int }
• Returns: 200 { attributevalue: T41 }

Delete attribute value image — DELETE /attributevalue/{id}/image

• Params: id: int
• Returns: 200 { attributevalue: { id: int, thumbW: int|null, thumbH: int|null, thumbHash: str|null, pics: T48[] } }

Add or replace attribute value image — POST /attributevalue/{id}/image

• Params: id: int, image/avif
• Returns: 201 { attributevalue: { id: int, fullHash: str, thumbW: int, thumbH: int, thumbHash: str, pics: T48[] } }

Section: /auth

Login with Google ID token — POST /auth/login

• Params: body: { idToken: str }
• Returns: 200 { message: str, user: T46 }

Logout — POST /auth/logout

none

• Returns: 200 { message: str }

Current user — GET /auth/me

none

• Returns: 200 { user: T46, googleClientId: str }

Set selected company — PUT /auth/selected-company

• Params: body: { companyId: int }
• Returns: 200 { user: T46 }

Section: /backup

List backups and service status — GET /backup

none

• Returns: 200 { status: { enabled: bool, isRunning: bool, dbProvider: str, mssqlWarning: bool, backupDir: str, retention: { hourlyMax: int, dailyMax: int, monthly: str }, counts: { hourly: int, daily: int, monthly: int }, latestHourly?: T10|null, latestDaily?: T10|null, latestMonthly?: T10|null }, backups: { counts: { hourly: int, daily: int, monthly: int }, hourly: T10[], daily: T10[], monthly: T10[] } }

List VFS files in a backup — GET /backup/{id}/vfs

• Params: id: str, query: companyId?: int
• Returns: 200 { backupId: str, companyId: int, files: { name: str, size: int, mime: str, mtime: str }[] }

Recover VFS file from a backup — POST /backup/{id}/vfs/recover

• Params: id: str, body: { path: str, companyId?: int }
• Returns: 200 { success: bool, backupId: str, companyId: int, path: str, sizeBytes: int, mime: str }

Section: /brand

List brands — GET /brand

• Params: query: offset?: int, limit?: int, includeSmallThumbs?: bool
• Returns: 200 { brands: { id: int, name: str, articleCount: int, pics: { fullHash: str, thumbW: int, thumbH: int, thumbHash: str, smallThumbW?: int|null, smallThumbH?: int|null, smallThumbBinary?: str|null }[], gsprpinfo?: str|null }[], total: int, offset: int, limit: int }

Create brand — POST /brand

• Params: body: { name: str, gsprpinfo?: str }
• Returns: 201 { brand: { id: int, name: str, pics: T48[], gsprpinfo?: str|null } }

Delete brand — DELETE /brand/{id}

• Params: id: int
• Returns: 204 void

Rename brand — PATCH /brand/{id}

• Params: id: int, body: { name?: str, gsprpinfo?: str }
• Returns: 200 { brand: { id: int, name: str, touchedArticleCount: int, gsprpinfo?: str|null } }

Delete brand image — DELETE /brand/{id}/image

• Params: id: int
• Returns: 200 { brand: { id: int, thumbW: int|null, thumbH: int|null, thumbHash: str|null, pics: T48[] } }

Add or replace brand image — POST /brand/{id}/image

• Params: id: int, image/avif
• Returns: 201 { brand: { id: int, fullHash: str, thumbW: int, thumbH: int, thumbHash: str, pics: T48[] } }

Section: /category

Create category — POST /category

• Params: body: { parentId: int, name: str }
• Returns: 201 { category: { id: int, parentId: int|null, sort: int, name: str } }

Export categories as ZIP — GET /category/export.zip

none

• Returns: 200 zip

Reorder sibling categories — PUT /category/order

• Params: body: { parentId: int, categoryIds: int[] }
• Returns: 200 { categoryIds: int[] }

Category tree — GET /category/tree

none

• Returns: 200 { languageId: int, tree: { id: int, sort: int, posterminalIds: int[], parentId?: int|null, name?: str|null, slug?: str|null, fullHash?: str|null, thumbW?: int|null, thumbH?: int|null, thumbHash?: str|null, articleCount?: int }[], articleCount: int }

Delete category — DELETE /category/{id}

• Params: id: int, query: recursive?: bool
• Returns: 204 void

Update category (rename or move) — PATCH /category/{id}

• Params: id: int, body: { name?: str, parentId?: int }
• Returns: 200 { category: { id: int, name: str, slug: str, parentId: int, sort: int } }

Articles in category — GET /category/{id}/articles

• Params: id: int
• Returns: 200 { articles: { id: int, sku: str, name: str, slug: str, track_stock: bool, optionsCount: int, articleListCount: int, childCount: int, net?: num|null, taxRate?: num|null, parentArticleId?: int|null, parentSku?: str|null, fullHash?: str|null, thumbW?: int|null, thumbH?: int|null, thumbHash?: str|null, brand?: T38|null }[] }

List category attribute values — GET /category/{id}/attributevalue

• Params: id: int
• Returns: 200 { attributevalues: { id: int, attributeId: int, attributeName: str, attributeValueId: int, value: str, sort: int, categoryId?: int, exclusive?: bool }[] }

Bulk set category attribute values — PUT /category/{id}/attributevalue

• Params: id: int, body: int[]
• Returns: 200 { attributevalues: { id: int, attributeId: int, attributeName: str, attributeValueId: int, value: str, sort: int, categoryId?: int, exclusive?: bool }[] }

Delete category image — DELETE /category/{id}/image

• Params: id: int
• Returns: 200 { category: { id: int, thumbW: int|null, thumbH: int|null, thumbHash: str|null } }

Add category image — POST /category/{id}/image

• Params: id: int, image/avif
• Returns: 201 { category: { id: int, thumbW: int, thumbH: int, thumbHash: str } }

List category properties — GET /category/{id}/property

• Params: id: int
• Returns: 200 { properties: { id: int, propertyId: int, name: str, exclusive: bool, value: str, sort: int, categoryId?: int }[] }

Bulk set category properties — PUT /category/{id}/property

• Params: id: int, body: { properties: { propertyId: int, value: str, sort?: int }[] }
• Returns: 200 { properties: { id: int, propertyId: int, name: str, exclusive: bool, value: str, sort: int, categoryId?: int }[] }

Delete category property — DELETE /category/{id}/property/{propertyId}

• Params: id: int, propertyId: int
• Returns: 200 { ok: bool }

Section: /company

List companies — GET /company

none

• Returns: 200 { companies: T24[] }

Create company — POST /company

• Params: body: { iso639: str, name: str, taxrate: num, reducedtaxrate: num }
• Returns: 201 { company: T24, user: T46 }

Export company catalog as zip archive (SSE) — GET /company/export

• Params: query: stream?: str
• Returns: 200 SSE

Export company catalog as zip archive (SSE) — POST /company/export

none

• Returns: 200 SSE

Get company history — GET /company/history

• Params: query: limit?: int
• Returns: 200 { history: { id: int, date: str, text: str, companyuserId?: int|null }[], truncated: bool }

Add company history entry — POST /company/history

• Params: body: { text: str }
• Returns: 201 { history: { id: int, date: str, text: str, companyuserId?: int|null } }

Import company catalog from zip archive (SSE) — POST /company/import

• Params: form: { file?: str }
• Returns: 200 SSE

List company settings — GET /company/setting

none

• Returns: 200 { settings: { key: str, value: str|null }[] }

Get company setting by key — GET /company/setting/{key}

• Params: key: str
• Returns: 200 { setting: { key: str, value: str|null } }

Upsert company setting — PUT /company/setting/{key}

• Params: key: str, body: { value: str, frontend?: bool }
• Returns: 200 { setting: { key: str, value: str|null } }

Delete company — DELETE /company/{id}

• Params: id: int
• Returns: 204 void

Update company — PUT /company/{id}

• Params: id: int, body: { iso639: str, name: str, taxrate: num, reducedtaxrate: num }
• Returns: 200 { company: T24 }

Section: /customergroup

List customer groups — GET /customergroup

none

• Returns: 200 { customergroups: { id: int, name: str, sort: int, editable: bool }[] }

Create customer group — POST /customergroup

• Params: body: { name: str }
• Returns: 201 { customergroup: T55 }

Reorder customer groups — PUT /customergroup/order

• Params: body: { customergroupIds: int[] }
• Returns: 200 { customergroupIds: int[] }

Delete customer group — DELETE /customergroup/{id}

• Params: id: int
• Returns: 204 void

Update customer group — PATCH /customergroup/{id}

• Params: id: int, body: { name: str }
• Returns: 200 { customergroup: T55 }

Section: /delivery

List deliveries — GET /delivery

none

• Returns: 200 { deliveries: { id: int, number: str, type: str, supplierId: int|null, date: str, externalNumber?: str|null, createdAt?: str, ledger?: T51 }[] }

Create delivery — POST /delivery

• Params: body: { externalNumber: str, date: str, lines: T34[], supplierId?: int|null, files?: { mimetype: str, name: str, content: str, sort?: int, size?: int, hash?: str, created?: str, modified?: str, meta?: { [k]: str } }[] }
• Returns: 201 T6

Parse document (SSE) — POST /delivery/parse

• Params: form: { file: str }

• Returns: 200 SSE

• Events:

  • status: { "message": "…" }
  • llm_call: { "model": "…", "promptSize": 0, "messages": 0 }
  • tool_call: { "name": "output_manifest" }
  • usage: { "input": 0, "cached": 0, "output": 0, "cost": 0 }
  • progress: ManifestResult
  • result: ManifestResult
  • error: { "message": "…" }

Delete delivery — DELETE /delivery/{id}

• Params: id: int
• Returns: 204 void

Get delivery — GET /delivery/{id}

• Params: id: int
• Returns: 200 T6

Update delivery — PATCH /delivery/{id}

• Params: id: int, body: { externalNumber?: str|null, date?: str, supplierId?: int|null, lines?: T34[], files?: { mimetype: str, name: str, content: str, sort?: int, size?: int, hash?: str, created?: str, modified?: str, meta?: { [k]: str } }[] }
• Returns: 200 T6

Get delivery attachment file content — GET /delivery/{id}/file/{fileId}

• Params: id: int, fileId: int, query: download?: bool
• Returns: 200 str

Generate and attach delivery note PDF (goods receipt) — POST /delivery/{id}/pdf

• Params: id: int
• Returns: 201 T13

Section: /entity

List entities — GET /entity

• Params: query: customergroupId?: int, role?: str
• Returns: 200 { entities: T36[] }

Create entity — POST /entity

• Params: body: { customergroupId: int, name: str, firstName?: str|null, number?: str }
• Returns: 201 T28

Peek next customer number — GET /entity/next-number

none

• Returns: 200 { number: str }

List entity addresses — GET /entity/{entityId}/address

• Params: entityId: int
• Returns: 200 { addresses: T19[] }

Create entity address — POST /entity/{entityId}/address

• Params: entityId: int, body: { addressType: str, firstName?: str|null, name?: str|null, street?: str|null, streetNumber?: str|null, zip?: str|null, city?: str|null, county?: str|null }
• Returns: 201 { address: T19 }

Delete entity address — DELETE /entity/{entityId}/address/{id}

• Params: entityId: int, id: int
• Returns: 204 void

Update entity address — PATCH /entity/{entityId}/address/{id}

• Params: entityId: int, id: int, body: { addressType?: str, firstName?: str|null, name?: str|null, street?: str|null, streetNumber?: str|null, zip?: str|null, city?: str|null, county?: str|null }
• Returns: 200 { address: T19 }

List entity contacts — GET /entity/{entityId}/contact

• Params: entityId: int
• Returns: 200 { contacts: T49[] }

Create entity contact — POST /entity/{entityId}/contact

• Params: entityId: int, body: { contactType: str, contact: str }
• Returns: 201 { contact: T49 }

Delete entity contact — DELETE /entity/{entityId}/contact/{id}

• Params: entityId: int, id: int
• Returns: 204 void

Update entity contact — PATCH /entity/{entityId}/contact/{id}

• Params: entityId: int, id: int, body: { contactType?: str, contact?: str }
• Returns: 200 { contact: T49 }

Delete entity — DELETE /entity/{id}

• Params: id: int
• Returns: 204 void

Get entity — GET /entity/{id}

• Params: id: int
• Returns: 200 T28

Update entity — PATCH /entity/{id}

• Params: id: int, body: { name?: str, firstName?: str|null, number?: str|null }
• Returns: 200 T28

Section: /events

Subscribe to update signals (SSE) — GET /events

none

• Returns: 200 SSE

• Events:

  • category: {}
  • articles: {}
  • article-<sku>: {}
  • stock: {}
  • ledger: {}
  • attributename: {}
  • propertyname: {}
  • labeltemplate: {}
  • printer: {}
  • warehouse: {}
  • vfs: {}
  • modelconversation: {}
  • modelconversation-<id>: {}
  • brand: { sender, brandId }
  • draft: { sender, action, name, content }
  • draft:request: { requestId, action, name, target, sender }

Section: /health

Database health check — GET /health

none

• Returns: 200 { ok: bool }

Section: /image

Full image by hash — GET /image/{fullHash}

• Params: fullHash: str
• Returns: 200 avif

Section: /labeltemplate

List label templates — GET /labeltemplate

none

• Returns: 200 { labeltemplates: { id: int, name: str, width: num, height: num, dpi: int, type: str, thumb?: str|null }[] }

Create label template — POST /labeltemplate

• Params: body: { name: str, width: num, height: num, dpi: int, type: str, content: T26 }
• Returns: 201 T12

Delete label template — DELETE /labeltemplate/{id}

• Params: id: int
• Returns: 204 void

Get label template by ID — GET /labeltemplate/{id}

• Params: id: int
• Returns: 200 T12

Update label template (partial) — PATCH /labeltemplate/{id}

• Params: id: int, body: { name?: str, width?: num, height?: num, dpi?: int, type?: str, content?: T26 }
• Returns: 200 T12

Update label template — PUT /labeltemplate/{id}

• Params: id: int, body: { name?: str, width?: num, height?: num, dpi?: int, type?: str, content?: T26 }
• Returns: 200 T12

Section: /ledger

Query ledger by manifest article ID or SKU — GET /ledger

• Params: query: manifestarticle_id?: int, sku?: str, transaction_type?: str
• Returns: 200 T20

Add ledger entry — POST /ledger

• Params: body: { manifestarticle_id: int, transaction_type: str, amount: num, transaction_text: str }
• Returns: 201 { ledger: T21 }

Query ledger by manifest article ID — GET /ledger/manifestarticle/{manifestarticleId}

• Params: manifestarticleId: int, query: transaction_type?: str
• Returns: 200 T20

Query ledger by article SKU — GET /ledger/sku/{sku}

• Params: sku: str, query: transaction_type?: str
• Returns: 200 T20

Section: /mcp

Model Context Protocol (MCP) Streamable HTTP endpoint — POST /mcp

none

• Returns: 200

List active MCP client authorizations — GET /mcp/authorizations

none

• Returns: 200

Revoke MCP client authorizations — DELETE /mcp/authorizations/{clientId}

• Params: clientId: str
• Returns: 200

Get MCP authorization prompt details — GET /mcp/authorize

• Params: query: client_id: str, redirect_uri: str, response_type?: str, code_challenge?: str, code_challenge_method?: str, state?: str, scope?: str
• Returns: 200

Grant or deny MCP client authorization — POST /mcp/authorize

• Params: body: { client_id: str, redirect_uri: str, action: str, code_challenge?: str, code_challenge_method?: str, state?: str, scope?: str }
• Returns: 200

List registered MCP clients — GET /mcp/clients

none

• Returns: 200

Delete registered MCP client — DELETE /mcp/clients/{clientId}

• Params: clientId: str
• Returns: 200

Section: /modelconversation

List conversations — GET /modelconversation

none

• Returns: 200 { conversations: T23[] }

Create conversation — POST /modelconversation

• Params: body: { provider: str, model: str }
• Returns: 201 { conversation: T23 }

Delete conversation — DELETE /modelconversation/{id}

• Params: id: int
• Returns: 204 void

Get conversation — GET /modelconversation/{id}

• Params: id: int
• Returns: 200 { conversation: T23 }

List conversation messages — GET /modelconversation/{id}/message

• Params: id: int
• Returns: 200 { messages: { id: int, conversation_id: int, created_at: str, role: str, message: str }[] }

Post a user message — POST /modelconversation/{id}/message

• Params: id: int, body: { message?: str, role?: str, tool_call_id?: str, content?: any, answer?: any }
• Returns: 201 { message: { id: int, conversation_id: int, created_at: str, role: str, message: str } }

Stream conversation events (SSE) — GET /modelconversation/{id}/stream

• Params: id: int
• Returns: 200 SSE

Section: /number

List number sequences — GET /number

none

• Returns: 200 { numbers: { id: int, type: str, prefix: str, padding: int, next: int }[] }

Update number sequence — PATCH /number/{id}

• Params: id: int, body: { prefix?: str, padding?: int, next?: int }
• Returns: 200 { number: { id: int, type: str, prefix: str, padding: int, next: int } }

Section: /oauth

OAuth 2.1 Authorization Endpoint (RFC 6749 & RFC 7636) — GET /oauth/authorize

• Params: query: client_id?: str, redirect_uri?: str, response_type?: str, code_challenge?: str, code_challenge_method?: str, state?: str no response body

OAuth 2.0 Token Introspection (RFC 7662) — POST /oauth/introspect

none

• Returns: 200

Dynamic Client Registration (RFC 7591) — POST /oauth/register

• Params: body: { redirect_uris: str[], client_name?: str }
• Returns: 201

OAuth 2.1 Token Endpoint (RFC 6749 & RFC 7636) — POST /oauth/token

• Params: application/x-www-form-urlencoded
• Returns: 200

Section: /order

List orders — GET /order

• Params: query: offset?: int, limit?: int, search?: str, onlyUnpaid?: bool, onlyUndelivered?: bool, seekMonths?: int
• Returns: 200 { orders: T2[], total: int, unfilteredTotal: int, offset: int, limit: int }

Create order — POST /order

• Params: body: { number: str, date: str, lines: T34[], entityId?: int|null }
• Returns: 201 T1

Delete order — DELETE /order/{id}

• Params: id: int
• Returns: 204 void

Get order — GET /order/{id}

• Params: id: int
• Returns: 200 T1

Update order — PATCH /order/{id}

• Params: id: int, body: { number?: str, date?: str, entityId?: int|null, lines?: T34[] }
• Returns: 200 T1

Get order attachment file content — GET /order/{id}/file/{fileId}

• Params: id: int, fileId: int, query: download?: bool
• Returns: 200 str

List payments of an order — GET /order/{id}/payment

• Params: id: int
• Returns: 200 { payments: T43[] }

Add payment to an order — POST /order/{id}/payment

• Params: id: int, body: { accountId: int, type: str, amount: num }
• Returns: 201 { payment: T43 }

Generate and attach order PDF — POST /order/{id}/pdf

• Params: id: int
• Returns: 201 T13

List shipments of an order — GET /order/{id}/shipment

• Params: id: int
• Returns: 200 { shipments: T5[] }

Create shipment for an order — POST /order/{id}/shipment

• Params: id: int, body: { lines: { sku: str, amount: num, name?: str, pu?: num, net?: num, rebate?: num, taxrate?: num, comment?: str }[], date?: str, externalNumber?: str }
• Returns: 201 { shipment: T5 }

List shippings of an order — GET /order/{id}/shipping

• Params: id: int
• Returns: 200 { shippings: T37[] }

Create shipping for an order — POST /order/{id}/shipping

• Params: id: int, body: { type: str, state: str, warehouseId?: int }
• Returns: 201 T32

Section: /package

Delete package — DELETE /package/{id}

• Params: id: int
• Returns: 204 void

Section: /payment

Delete payment — DELETE /payment/{id}

• Params: id: int
• Returns: 204 void

Section: /posterminal

List POS terminals — GET /posterminal

none

• Returns: 200 { posterminals: T16[] }

Create POS terminal — PUT /posterminal

• Params: body: { name: str, rootCategoryId?: int|null, syncRootArticles?: bool }
• Returns: 200 { posterminal: T16 }

Delete POS terminal — DELETE /posterminal/{id}

• Params: id: int
• Returns: 204 void

Update POS terminal — PATCH /posterminal/{id}

• Params: id: int, body: { name?: str, rootCategoryId?: int|null, syncRootArticles?: bool, pairingpin?: str|null }
• Returns: 200 { posterminal: T16 }

Disable all categories on terminal — DELETE /posterminal/{id}/all

• Params: id: int
• Returns: 200 T56

Enable all categories on terminal — PUT /posterminal/{id}/all

• Params: id: int
• Returns: 200 T56

Disable category on terminal — DELETE /posterminal/{id}/category/{categoryId}

• Params: id: int, categoryId: int
• Returns: 200 T56

Enable category on terminal — PUT /posterminal/{id}/category/{categoryId}

• Params: id: int, categoryId: int
• Returns: 200 T56

Section: /printer

List printers — GET /printer

none

• Returns: 200 { printers: T33[] }

Create printer — POST /printer

• Params: body: { address: str, type: str, model?: str|null, serial?: str|null, sort?: int, desc?: str|null }
• Returns: 201 T27

Reorder printers — PUT /printer/order

• Params: body: { printerIds: int[] }
• Returns: 200 { printerIds: int[] }

Delete printer — DELETE /printer/{id}

• Params: id: int
• Returns: 204 void

Get printer by ID — GET /printer/{id}

• Params: id: int
• Returns: 200 T27

Update printer (partial) — PATCH /printer/{id}

• Params: id: int, body: { address?: str, type?: str, model?: str|null, serial?: str|null, sort?: int, desc?: str|null }
• Returns: 200 T27

Update printer — PUT /printer/{id}

• Params: id: int, body: { address?: str, type?: str, model?: str|null, serial?: str|null, sort?: int, desc?: str|null }
• Returns: 200 T27

Section: /propertyname

List property names — GET /propertyname

none

• Returns: 200 { propertynames: T42[] }

Create property name — POST /propertyname

• Params: body: { name: str, sort?: int, exclusive?: bool }
• Returns: 201 { propertyname: T42 }

Reorder property names — PUT /propertyname/order

• Params: body: { propertynameIds: int[] }
• Returns: 200 { ok: bool }

Delete property name — DELETE /propertyname/{id}

• Params: id: int
• Returns: 200 { ok: bool }

Update property name — PATCH /propertyname/{id}

• Params: id: int, body: { name?: str, sort?: int, exclusive?: bool }
• Returns: 200 { propertyname: T42 }

Section: /public

Receipt crash dump — POST /public/telemetry/crash

• Params: body: { content: any }
• Returns: 200 { ok: bool, filename: str }

List public articles — GET /public/{companyId}/articles

• Params: companyId: int, query: categoryId?: int, search?: str, limit?: int, offset?: int
• Returns: 200 { articles: { id: int, sku: str, name: str, slug: str, net: num|null, taxRate: num|null, gross: num|null, trackStock: bool, brand: { id: int|null, name: str }, fullHash: str|null, thumbW: int|null, thumbH: int|null, thumbHash: str|null }[] }

Get public article detail — GET /public/{companyId}/articles/{sku}

• Params: companyId: int, sku: str
• Returns: 200 { article: { id: int, sku: str, name: str, slug: str, description: str, unitamount: num|null, weight: num|null, trackStock: bool, unit: {}|null, brand: {}|null, price: {}|null, prices: {}[], categories: {}[], photos: {}[], eans: str[], isParent: bool, parentSku: str|null, variants: {}[] } }

List public categories — GET /public/{companyId}/categories

• Params: companyId: int
• Returns: 200 { categories: { id: int, parentId: int|null, sort: int, name: str, slug: str, fullHash: str|null, thumbW: int|null, thumbH: int|null, thumbHash: str|null }[] }

Section: /quote

List quotes — GET /quote

• Params: query: offset?: int, limit?: int, search?: str, seekMonths?: int
• Returns: 200 { quotes: T9[], total: int, unfilteredTotal: int, offset: int, limit: int }

Create quote — POST /quote

• Params: body: { number: str, date: str, lines: T34[], entityId?: int|null }
• Returns: 201 T8

Delete quote — DELETE /quote/{id}

• Params: id: int
• Returns: 204 void

Get quote — GET /quote/{id}

• Params: id: int
• Returns: 200 T8

Update quote — PATCH /quote/{id}

• Params: id: int, body: { number?: str, date?: str, entityId?: int|null, lines?: T34[] }
• Returns: 200 T8

Get quote attachment file content — GET /quote/{id}/file/{fileId}

• Params: id: int, fileId: int, query: download?: bool
• Returns: 200 str

Generate and attach quote PDF — POST /quote/{id}/pdf

• Params: id: int
• Returns: 201 T13

Section: /serper

Crawl image from URL, crop white/transparency borders, and return AVIF — POST /serper/image

• Params: body: { url: str }
• Returns: 200 avif

Search images via Serper.dev and stream WebP thumbnails (SSE) — POST /serper/images

• Params: body: { q: str, gl?: str, hl?: str, num?: int, preferSource?: bool }

• Returns: 200 SSE

• Events:

  • images: { "images": [ { "id": 0, "url": "…", "width": 1000, "height": 800 } ] }
  • thumb: { "id": 0, "dataUrl": "data:image/webp;base64,…" }
  • done: { "total": 100 }
  • error: { "error": "…" }

Section: /shipment

Delete shipment — DELETE /shipment/{id}

• Params: id: int
• Returns: 204 void

Get shipment by ID — GET /shipment/{id}

• Params: id: int
• Returns: 200 { shipment: T5 }

Get shipment attachment file content — GET /shipment/{id}/file/{fileId}

• Params: id: int, fileId: int, query: download?: bool
• Returns: 200 str

Generate and attach shipment PDF (delivery note) — POST /shipment/{id}/pdf

• Params: id: int
• Returns: 201 T13

List packages of a shipment — GET /shipment/{id}/shipping

• Params: id: int
• Returns: 200 { shippings: T37[] }

Create package for a shipment — POST /shipment/{id}/shipping

• Params: id: int, body: { type: str, state: str, trackingCode?: str, carrier?: str, warehouseId?: int }
• Returns: 201 T32

Section: /shipping

Delete shipping — DELETE /shipping/{id}

• Params: id: int
• Returns: 204 void

Update shipping — PATCH /shipping/{id}

• Params: id: int, body: { type?: str, state?: str, trackingCode?: str, carrier?: str, warehouseId?: int }
• Returns: 200 T32

List packages of a shipping — GET /shipping/{id}/package

• Params: id: int
• Returns: 200 { packages: { id: int, shippingId: int, entityaddressId: int, number: str, type: str, state: str, details?: str|null }[] }

Create package for a shipping — POST /shipping/{id}/package

• Params: id: int, body: { entityaddressId: int, type: str, state: str, details?: str }
• Returns: 201 { package: { id: int, shippingId: int, entityaddressId: int, number: str, type: str, state: str, details?: str|null } }

Section: /smallthumb

Small thumb image by hash — GET /smallthumb/{fullHash}

• Params: fullHash: str
• Returns: 200 avif

Section: /stock

Adjust stock manually — POST /stock/adjust

• Params: body: { sku?: str, warehouseId?: int, amount?: num, text?: str|null, lines?: { sku: str, amount: num, warehouseId?: int, text?: str }[] }
• Returns: 201 { manifest: { id: int, number: str, type: str, date: str, createdAt: str }, lines: { manifestarticle_id: int, sku: str, name: str, warehouse_id: int, amount: num, text: str }[], ledger: T21[] }

Section: /supplier

List suppliers — GET /supplier

none

• Returns: 200 { suppliers: T50[] }

Create supplier — POST /supplier

• Params: body: { name: str }
• Returns: 201 { supplier: T50 }

Delete supplier — DELETE /supplier/{id}

• Params: id: int
• Returns: 204 void

Update supplier — PATCH /supplier/{id}

• Params: id: int, body: { name: str }
• Returns: 200 { supplier: T50 }

List supplier articles by SKUs — GET /supplier/{id}/articles

• Params: id: int, query: skus?: string
• Returns: 200 { articles: { id: int, articleId: int, entityId: int, pu: num, sort: int, article: { id: int, sku: str, name?: str|null, slug?: str|null, photos?: { sort: int, fullHash: str, thumbW: int, thumbH: int, thumbHash: str }[], eans?: str[] }, supplierName?: str|null, sku?: str|null, stock?: num|null, priceId?: int|null, price?: T54|null }[] }

Query supplier articles by SKUs (bulk) — POST /supplier/{id}/articles

• Params: id: int, body?: { skus?: str[] }
• Returns: 200 { articles: { id: int, articleId: int, entityId: int, pu: num, sort: int, article: { id: int, sku: str, name?: str|null, slug?: str|null, photos?: { sort: int, fullHash: str, thumbW: int, thumbH: int, thumbHash: str }[], eans?: str[] }, supplierName?: str|null, sku?: str|null, stock?: num|null, priceId?: int|null, price?: T54|null }[] }

Section: /thumb

Thumb image by hash — GET /thumb/{fullHash}

• Params: fullHash: str
• Returns: 200 avif

Section: /unit

Delete unit — DELETE /unit

• Params: query: si: str
• Returns: 204 void

List units — GET /unit

none

• Returns: 200 { units: T40[] }

Upsert unit — PUT /unit

• Params: body: { si: str, basesi: str, basesifactor: num, symbol: str, name: str }
• Returns: 200 { unit: T40 }

Section: /v1

JTL-POS category synchronization — GET /v1/category

• Params: query: lastChangedCategory?: str, limit?: int
• Returns: 200 {}[]

POS discovery and pairing — GET /v1/client

• Params: query: authCode: str, name?: str
• Returns: 200 { authCode: str|null, authToken: str|null, certificateFingerprint: str, certificateSerialNumber: str, mandantId: str, mandantName: str|null, mandantDatabase: str|null, serverFingerprint: str|null, name: str|null, serverTimestamp: str }

POS sync initialization counts — GET /v1/init

• Params: query: lastChangedProduct?: int, lastChangedCategory?: int, lastChangedCustomer?: int, lastChangedCustomerGroup?: int, lastChangedCompositeProduct?: int, lastChangedDeletedEntity?: int
• Returns: 200 { version: str, product_count: str, category_count: str, customer_count: str, customerGroup_count: str, compositeProduct_count: str, configurationGroup_count: str, configurationItem_count: str, deletedEntity_count: str, max_orderId_count: str }

POS product image delivery — GET /v1/pimage

• Params: query: path: str, w?: int, h?: int, format?: str
• Returns: 200 jpeg

JTL-POS product catalog synchronization — GET /v1/product

• Params: query: lastChangedProduct?: str, limit?: int
• Returns: 200 {}[]

Section: /vfs

List virtual filesystem files — GET /vfs

none

• Returns: 200 { files: { name: str, size: int, mime: str, updated_at: str, created_at: str, isText: bool, isImage: bool, isPdf: bool }[] }

Respond to a frontend draft request — POST /vfs/drafts/response

• Params: body: { requestId: str, content?: any, error?: str, files?: any[] }
• Returns: 200 { success: bool }

Create directory in virtual filesystem — POST /vfs/mkdir

• Params: body: { path: str }
• Returns: 200 { success: bool, dir: str }

Rename or move a virtual filesystem file or directory — POST /vfs/rename

• Params: body: { oldPath: str, newPath: str }
• Returns: 200 { success: bool, oldPath: str, newPath: str }

Upload files to virtual filesystem — POST /vfs/upload

• Params: form: { files: str[], targetDir?: str }
• Returns: 200 { success: bool, uploaded: { name: str, size: int, mime: str }[] }

Delete a virtual filesystem file — DELETE /vfs/{*path}

• Params: path: str
• Returns: 200 { success: bool, deleted: str }

Get a virtual filesystem file — GET /vfs/{*path}

• Params: path: str, query: download?: bool, raw?: bool
• Returns: 200 str

Execute a virtual filesystem applet — POST /vfs/{*path}

• Params: path: str, body?: { input?: {}, timeout?: int, max_output?: int }
• Returns: 200 { ok: bool, result: str, columns: { name: str, type: str }[], rows: int, stdout: str, consoleLines: int, durationMs: int, description?: str, warnings?: str[], truncated?: bool, truncationNote?: str }

Create or overwrite a virtual filesystem file — PUT /vfs/{*path}

• Params: path: str, body: { content: str, mime?: str }
• Returns: 200 { success: bool, file: { name: str, size: int, mime: str, updated_at: str } }

Section: /warehouse

List warehouses — GET /warehouse

none

• Returns: 200 { warehouses: T55[] }

Create warehouse — POST /warehouse

• Params: body: { name: str, sort?: int }
• Returns: 201 T53

Reorder warehouses — PUT /warehouse/order

• Params: body: { warehouseIds: int[] }
• Returns: 200 { warehouseIds: int[] }

Delete warehouse — DELETE /warehouse/{id}

• Params: id: int
• Returns: 204 void

Get warehouse by ID — GET /warehouse/{id}

• Params: id: int
• Returns: 200 T53

Update warehouse (partial) — PATCH /warehouse/{id}

• Params: id: int, body: { name?: str, sort?: int }
• Returns: 200 T53

Update warehouse — PUT /warehouse/{id}

• Params: id: int, body: { name?: str, sort?: int }
• Returns: 200 T53