Developers

Inventrackr API & webhooks

Read and update a storage’s products from your shop system, spreadsheets or scripts, and get a signed HTTPS request whenever products or suppliers change. Available to storages whose owner is on Inventrackr Pro.

Base URL
https://api-production-c3ca.up.railway.app/api/v1
Auth
Authorization: Bearer itk_live_…
Format
JSON over HTTPS
On this page

Overview

The API is a small REST API under https://api-production-c3ca.up.railway.app/api/v1. Each API key belongs to one storage and can only see and change that storage: its products (called items in the API) and suppliers. To work with several storages, create a key in each.

  • Read products and suppliers, or only what changed since a point in time.
  • Write products, suppliers and stock changes (absolute counts or +/− adjustments with a reason).
  • Read purchase orders, stock counts, reports and the full audit log.
  • Webhooks tell your server about product, stock and supplier changes made anywhere (the web, the iPhone and Android apps, CSV import or the API), plus purchase orders, transfers, counts, approvals and expiring batches.

API keys and webhooks are part of Inventrackr Pro. Only the storage owner can create them, and they work while the owner’s plan is Pro. Changes made through the API appear in the storage’s activity history as “API key name”, and team members see them live like any other change.

Quick start

  1. In the Inventrackr web app, open the storage, then Storage settings → Integrations (storage owners only).
  2. Under API keys, enter a name (for example “Shop till sync”), choose Read only or Read & write, and select Create key.
  3. Copy the key right away. It starts with itk_live_ and is shown only once: Inventrackr stores just a hash of it.
  4. Call the API with the key in the Authorization header:
List the first 100 items
curl "https://api-production-c3ca.up.railway.app/api/v1/items?limit=100" \
  -H "Authorization: Bearer $INVENTRACKR_API_KEY"

The response is a page of items plus a cursor for the next page:

200 OK
{
  "items": [
    {
      "id": "3f6c2a8e-6b1d-4c1e-9a52-2d8f0c7b9e10",
      "name": "Espresso beans",
      "description": "House blend, 1 kg bags",
      "barcode": "8714789120045",
      "quantity": 3.5,
      "minimumQuantity": 5,
      "unit": "kg",
      "priceCents": 1899,
      "supplierId": "9b2e7c44-1f0a-4d3b-8e6f-5a1c2d3e4f50",
      "supplierName": "Roastery Co.",
      "hasImage": false,
      "imageVersion": 0,
      "version": 7,
      "createdAt": "2026-10-02T14:05:11.482Z",
      "updatedAt": "2026-11-18T09:31:27.103Z",
      "stockStatus": "lowStock",
      "costCents": 1150,
      "stockValueCents": 4025,
      "retailValueCents": 6647,
      "location": "Aisle 3 / B2",
      "barcodes": [
        "8714789120045",
        "BEANS-1KG"
      ],
      "tags": [
        "Coffee",
        "Bar"
      ],
      "customFields": {
        "5d0c9a1e-7b3f-4e2a-8c6d-1f2e3a4b5c6d": "Brazil"
      },
      "trackBatches": true,
      "batches": [
        {
          "id": "c1d2e3f4-a5b6-4c7d-8e9f-0a1b2c3d4e5f",
          "code": "L42",
          "expiresOn": "2027-03-31",
          "quantity": 3.5,
          "receivedAt": "2026-11-02T10:00:00.000Z",
          "costCents": 1150
        }
      ],
      "kit": null,
      "onOrderQuantity": 10
    }
  ],
  "nextCursor": "WyIyMDI2LTExLTE4IDA5OjMxOjI3LjEwMyswMCIsIjNmNmMyYThlLTZiMWQtNGMxZS05YTUyLTJkOGYwYzdiOWUxMCJd"
}

Authentication

Send the key as a bearer token on every request:

HTTP
Authorization: Bearer itk_live_…
API key scopes
AccessCan call
Read only (read)Every GET endpoint: storage, items, suppliers, purchase orders, counts, reports and the audit export
Read & write (write)Everything above, plus every POST, PATCH and DELETE on items and suppliers
  • Keys look like itk_live_ followed by 32 URL-safe characters. The app lists each key by name, its first characters, when it was created and when it was last used.
  • Revoking a key in the app takes effect immediately; a write still in progress when the key is revoked is refused.
  • A missing, malformed or revoked key gets 401 API_KEY_INVALID. If the storage owner’s Pro plan has ended, every key of the storage gets 401 PLAN_REQUIRED until Pro is active again; the keys themselves are kept.
  • A read-only key calling a write endpoint gets 403 INSUFFICIENT_SCOPE.

Rate limits

Rate limits
LimitApplies to
120 requests per minuteEach API key
600 requests per minuteEach client IP address (IPv6: per /64), counting every /api/v1 request, including ones with invalid keys

Limits use fixed one-minute windows. Every authenticated response carries the key’s budget, so you can slow down before hitting it:

Rate limit headers
HeaderValue
X-RateLimit-LimitRequests allowed per window for this key (120).
X-RateLimit-RemainingRequests left in the current window.
X-RateLimit-ResetWhen the window resets, in Unix seconds.
Retry-AfterOn 429 only: seconds to wait before retrying.

Over a limit, the API answers 429 RATE_LIMITED with a Retry-After header giving the seconds until the window resets. Wait that long before retrying.

The API can also answer 503 BUSY with Retry-After: 1 when a change collided with another change at the same moment; it’s safe to retry. A page of up to 500 items counts as one request, so prefer large pages to many small ones.

Errors

Errors are JSON with a human-readable error message and a stable machine-readable code (every error has one). Some codes carry extra fields. Branch on the status and code, never on the message text.

401 Unauthorized
{
  "error": "This API key is invalid or was revoked",
  "code": "API_KEY_INVALID"
}
Error responses
StatuscodeWhen
400VALIDATION_FAILEDThe body or query failed validation. The response has a details array (see below).
400INVALID_IDAn {id} in the path isn’t a UUID.
400INVALID_JSONThe body isn’t valid JSON.
400INVALID_CURSORThe cursor parameter isn’t one the API returned.
400INVALID_VALUEA value can’t be stored (for example invalid Unicode such as lone surrogates, or a number out of range).
400IDEMPOTENCY_KEY_INVALIDThe Idempotency-Key isn’t 1–120 visible ASCII characters.
400SUPPLIER_NOT_FOUND, CUSTOM_FIELD_INVALID, KIT_INVALID, KIT_CYCLEA referenced supplier, custom field or kit component is invalid (CUSTOM_FIELD_INVALID carries fieldId).
401API_KEY_INVALIDNo key, a malformed key, or a revoked key.
401PLAN_REQUIREDThe storage owner’s plan isn’t Pro (anymore). It stays 401 for compatibility.
403INSUFFICIENT_SCOPEA read-only key called a write endpoint.
404NOT_FOUNDThe item (or other record) doesn’t exist in this key’s storage, or the path doesn’t exist.
404STORAGE_GONEThe storage was deleted.
409VERSION_CONFLICTThe item’s version is newer than the one you sent.
409STOCK_CHANGEDThe stock no longer equals the expectedQuantity you sent.
409UNIT_CHANGEDThe item’s unit isn’t the unit you sent.
409APPROVAL_REQUIREDA full item edit would lower stock beyond the storage’s approval limit. Use Change stock, which can wait for approval.
409BATCH_NOT_FOUND, KIT_NOT_STOCKED, BATCHES_REQUIRE_ADJUSTMENTThe batch doesn’t exist, the item is a kit that isn’t stocked itself, or a batch item’s unit and quantity changed together.
409IDEMPOTENCY_IN_PROGRESSA request with the same Idempotency-Key is still running. Retry shortly.
409DUPLICATE, REFERENCE_REMOVEDA unique value is taken, or something the change refers to was deleted at the same moment. Re-read and retry.
413PAYLOAD_TOO_LARGEThe request body is larger than 256 KB.
422IDEMPOTENCY_MISMATCHThe Idempotency-Key was already used for a different method, path or body.
429RATE_LIMITEDRate limit exceeded. See Retry-After.
500INTERNAL_ERRORUnexpected server error. Retry with backoff; contact support if it persists.
503BUSYA conflicting change happened at the same time. Retry after Retry-After seconds.

Validation errors list each problem with its path in the request:

400 Bad Request
{
  "error": "Invalid request",
  "code": "VALIDATION_FAILED",
  "details": [
    {
      "path": "name",
      "message": "Too small: expected string to have >=1 characters",
      "code": "too_small"
    },
    {
      "path": "quantity",
      "message": "Use at most 3 decimal places",
      "code": "custom"
    }
  ]
}

Pagination & syncing

GET /items returns items ordered by updatedAt (oldest first, ties broken by id), so you can page through everything or only what changed. Pass limit (1–500, default 100). When there are more items, the response’s nextCursor is a string: send it back as cursor (with the same other parameters) to get the next page. On the last page nextCursor is null. Cursors are opaque; don’t build or modify them.

Next page
curl "https://api-production-c3ca.up.railway.app/api/v1/items?limit=500&cursor=WyIyMDI2LTExLTE4IDA5OjMx…" \
  -H "Authorization: Bearer $INVENTRACKR_API_KEY"

To keep a copy in sync, remember the largest updatedAt you have seen and next time ask for updatedSince that value. updatedSince is inclusive (items updated at or after it), so you’ll see the last item again: upsert by id and use version to skip what you already have. The value must be an ISO 8601 date-time with Z or an offset; URL-encode a + offset as %2B.

Changes since your last sync
curl "https://api-production-c3ca.up.railway.app/api/v1/items?updatedSince=2026-11-18T09:31:27.103Z&limit=500" \
  -H "Authorization: Bearer $INVENTRACKR_API_KEY"

Deleted items stop appearing in the list. To learn about deletions while syncing, add includeDeleted=true: deletion tombstones are then merged into the same pages, in the same (time, id) order, so one cursor covers both. Tombstones are kept for 90 days; if your last sync is older, do a full listing.

GET /items?includeDeleted=true&updatedSince=…
{
  "items": [
    {
      "id": "3f6c2a8e-6b1d-4c1e-9a52-2d8f0c7b9e10",
      "name": "Espresso beans",
      "description": "House blend, 1 kg bags",
      "barcode": "8714789120045",
      "quantity": 3.5,
      "minimumQuantity": 5,
      "unit": "kg",
      "priceCents": 1899,
      "supplierId": "9b2e7c44-1f0a-4d3b-8e6f-5a1c2d3e4f50",
      "supplierName": "Roastery Co.",
      "hasImage": false,
      "imageVersion": 0,
      "version": 7,
      "createdAt": "2026-10-02T14:05:11.482Z",
      "updatedAt": "2026-11-18T09:31:27.103Z",
      "stockStatus": "lowStock",
      "costCents": 1150,
      "stockValueCents": 4025,
      "retailValueCents": 6647,
      "location": "Aisle 3 / B2",
      "barcodes": [
        "8714789120045",
        "BEANS-1KG"
      ],
      "tags": [
        "Coffee",
        "Bar"
      ],
      "customFields": {
        "5d0c9a1e-7b3f-4e2a-8c6d-1f2e3a4b5c6d": "Brazil"
      },
      "trackBatches": true,
      "batches": [
        {
          "id": "c1d2e3f4-a5b6-4c7d-8e9f-0a1b2c3d4e5f",
          "code": "L42",
          "expiresOn": "2027-03-31",
          "quantity": 3.5,
          "receivedAt": "2026-11-02T10:00:00.000Z",
          "costCents": 1150
        }
      ],
      "kit": null,
      "onOrderQuantity": 10
    },
    {
      "id": "0b9a8c7d-6e5f-4a3b-2c1d-0e9f8a7b6c5d",
      "deleted": true,
      "deletedAt": "2026-11-18T09:40:02.311Z"
    }
  ],
  "nextCursor": null
}

GET /suppliers still returns a plain array of every supplier. Pass limit (1–500) to page in name order instead: when there are more, the response has an X-Next-Cursor header; send it back as cursor.

Idempotent retries

Every POST, PATCH and DELETE accepts an optional Idempotency-Key header: any 1–120 visible ASCII characters, such as a UUID you generate per operation. If a request times out, send it again with the same key and the same body: the change is applied once.

Remove 2 kg, safe to retry
curl -X PATCH "https://api-production-c3ca.up.railway.app/api/v1/items/3f6c2a8e-6b1d-4c1e-9a52-2d8f0c7b9e10/quantity" \
  -H "Authorization: Bearer $INVENTRACKR_API_KEY" \
  -H "Idempotency-Key: 7c9e6679-7425-40de-944b-e07fc1f90ae7" \
  -H "Content-Type: application/json" \
  -d '{"delta": -2, "reason": "sold"}'
  • The first response (any status below 500) is stored for 24 hours per API key. A repeat gets the same status and body, with the header Idempotent-Replayed: true.
  • The same key with a different method, path or body is refused with 422 IDEMPOTENCY_MISMATCH.
  • While the first request is still running, a repeat gets 409 IDEMPOTENCY_IN_PROGRESS; retry a moment later.
  • A 5xx response isn’t stored, so a retry with the same key runs the request again.

Approvals

A storage owner can require approval for large stock decreases (by units or by value), for item deletions and for applying stock counts. API keys are never approvers, so under those rules:

  • PATCH /items/{id}/quantity and DELETE /items/{id} answer 202 Accepted with { "status": "pending_approval", "requestId": "…" }. Nothing has changed yet: the change is applied when someone with the Approve privilege accepts it in the app (the activity then shows “API key name” as the requester). Send an Idempotency-Key so a retry doesn’t create a second request.
  • PATCH /items/{id} can’t wait for approval: a large decrease is refused with 409 APPROVAL_REQUIRED. Change stock with the quantity endpoint instead.

Subscribe to the approval.resolved webhook to learn the outcome.

Objects

Timestamps are ISO 8601 strings in UTC. IDs are lowercase UUIDs.

Item

Item fields
FieldTypeDescription
idstring (UUID)The item’s ID.
namestringUp to 160 characters.
descriptionstringUp to 4,000 characters; empty string when not set.
barcodestringUp to 120 characters; empty string when not set. Not required to be unique.
quantitynumberCurrent stock, ≥ 0, up to 3 decimal places.
minimumQuantitynumberThe “low stock at” level, ≥ 0, up to 3 decimal places.
unitstringOne of each, pack, box, case, roll, ml, l, g, kg, oz, lb, fl_oz, gal, cm, m, in, ft.
priceCentsintegerUnit price in the smallest currency unit (cents) of the storage’s currency, which is set in the app.
supplierIdstring (UUID) | nullThe item’s supplier, if any.
supplierNamestring | nullThat supplier’s name.
hasImagebooleanWhether the item has a photo (download it with GET /items/{id}/image).
imageVersionintegerChanges when the photo changes.
versionintegerIncreases by one with every change to the item.
createdAtstring (date-time)When the item was created.
updatedAtstring (date-time)When the item last changed.
stockStatusstringoutOfStock when quantity is 0, lowStock when quantity ≤ minimumQuantity, else inStock.
costCentsinteger | nullUnit purchase cost in cents; null when unknown. Receiving a purchase order updates it as a moving average.
stockValueCentsinteger | nullquantity × costCents, rounded; null when costCents is null.
retailValueCentsintegerquantity × priceCents, rounded.
locationstringBin location such as “Aisle 3 / B2”, up to 80 characters; empty string when not set.
barcodesstring[]Every barcode, the primary one (barcode) first, up to 10. Empty when none.
tagsstring[]Up to 20 tags of 1–30 characters, unique ignoring case.
customFieldsobjectValues of the storage’s custom fields by field ID: text, number, YYYY-MM-DD date, select option or boolean. The definitions are in GET /storage.
trackBatchesbooleanWhether stock is tracked in batches (lots). The quantity is then the sum of batches.
batchesBatch[]{ id, code, expiresOn, quantity, receivedAt, costCents }, first-expiring first; empty unless trackBatches. A batch with an empty code and no expiry holds stock added without batch details.
kitobject | nullFor kits: { stocked, components: [{ itemId, name, unit, quantity }], buildableQuantity }. When stocked is false, selling the kit consumes its components.
onOrderQuantitynumberQuantity still to arrive on sent or partly received purchase orders.

Fields added later are always optional in requests; omitting them leaves them unchanged. Free storages read them but can’t change them.

Item
{
  "id": "3f6c2a8e-6b1d-4c1e-9a52-2d8f0c7b9e10",
  "name": "Espresso beans",
  "description": "House blend, 1 kg bags",
  "barcode": "8714789120045",
  "quantity": 3.5,
  "minimumQuantity": 5,
  "unit": "kg",
  "priceCents": 1899,
  "supplierId": "9b2e7c44-1f0a-4d3b-8e6f-5a1c2d3e4f50",
  "supplierName": "Roastery Co.",
  "hasImage": false,
  "imageVersion": 0,
  "version": 7,
  "createdAt": "2026-10-02T14:05:11.482Z",
  "updatedAt": "2026-11-18T09:31:27.103Z",
  "stockStatus": "lowStock",
  "costCents": 1150,
  "stockValueCents": 4025,
  "retailValueCents": 6647,
  "location": "Aisle 3 / B2",
  "barcodes": [
    "8714789120045",
    "BEANS-1KG"
  ],
  "tags": [
    "Coffee",
    "Bar"
  ],
  "customFields": {
    "5d0c9a1e-7b3f-4e2a-8c6d-1f2e3a4b5c6d": "Brazil"
  },
  "trackBatches": true,
  "batches": [
    {
      "id": "c1d2e3f4-a5b6-4c7d-8e9f-0a1b2c3d4e5f",
      "code": "L42",
      "expiresOn": "2027-03-31",
      "quantity": 3.5,
      "receivedAt": "2026-11-02T10:00:00.000Z",
      "costCents": 1150
    }
  ],
  "kit": null,
  "onOrderQuantity": 10
}

Supplier

Supplier fields
FieldTypeDescription
idstring (UUID)The supplier’s ID.
namestringThe supplier’s name.
contactNamestringEmpty string when not set.
contactEmailstringEmpty string when not set.
contactPhonestringEmpty string when not set.
createdAtstring (date-time)When the supplier was added.
email, phonestringRead-only aliases of contactEmail and contactPhone. Write through the contact fields.
notesstringUp to 2,000 characters.
leadTimeDaysintegerDays from ordering to delivery, 0–365 (default 7). Used by reorder suggestions.
currencyCodestring | nullThe supplier’s currency (e.g. EUR); null means the storage’s currency.
Supplier
{
  "id": "9b2e7c44-1f0a-4d3b-8e6f-5a1c2d3e4f50",
  "name": "Roastery Co.",
  "contactName": "Sam Rivera",
  "contactEmail": "orders@roastery.example",
  "contactPhone": "+1 555 0100",
  "createdAt": "2026-09-14T08:12:40.019Z",
  "email": "orders@roastery.example",
  "phone": "+1 555 0100",
  "notes": "Net 30",
  "leadTimeDays": 7,
  "currencyCode": null
}

Endpoints

Who am I

GET/api/v1/meRead or write key

Returns { storage: { id, name, currencyCode }, apiKey: { id, name, scope } }. It’s the cheapest way to test a key and to label a connection (Zapier and Make use it).

Get the storage

GET/api/v1/storageRead or write key

Returns the key’s storage: { id, name, location, currencyCode, createdAt, pro, settings, customFields, apiKey: { name, scope } }. settings holds the expiry warning window, the reorder review period and the approval rules; customFields lists the custom field definitions { id, name, type, options, required, position } (type is text, number, date, select or checkbox). Use it as an auth check too.

List items

GET/api/v1/itemsRead or write key

Query parameters
ParameterTypeDescription
limitinteger, 1–500Items per page. Default 100.
cursorstringThe nextCursor from the previous page.
updatedSincedate-timeOnly items whose updatedAt is at or after this moment, e.g. 2026-11-01T00:00:00Z.
searchstringMatches name, barcodes, description, location, tags and custom field values.
barcodestringExact match on any of the item’s barcodes (a scan lookup).
tagstringItems with this tag (ignoring case).
locationstringItems at this location (exact, ignoring case).
supplierIdUUID | noneItems of this supplier, or none for items without one.
includeDeletedtrue | falseAlso return deletion tombstones (see Pagination & syncing).
Shell
curl "https://api-production-c3ca.up.railway.app/api/v1/items?limit=100" \
  -H "Authorization: Bearer $INVENTRACKR_API_KEY"

Returns 200 with { "items": [Item, …], "nextCursor": string | null }.

Get an item

GET/api/v1/items/{id}Read or write key

Shell
curl "https://api-production-c3ca.up.railway.app/api/v1/items/3f6c2a8e-6b1d-4c1e-9a52-2d8f0c7b9e10" \
  -H "Authorization: Bearer $INVENTRACKR_API_KEY"

Returns 200 with an Item, or 404 NOT_FOUND.

GET/api/v1/items/{id}/imageRead or write key

Returns the item’s photo as image bytes (JPEG, PNG or WebP), or 404 NOT_FOUND when it has none.

Create an item

POST/api/v1/itemsWrite key

Request body
FieldTypeRules
namestring, required1–160 characters after trimming spaces.
descriptionstringUp to 4,000 characters. Default empty.
barcodestringUp to 120 characters after trimming. Default empty.
quantitynumber0 to 999,999,999,999, at most 3 decimals. Default 0.
minimumQuantitynumberSame rules as quantity. Default 0.
unitstringOne of the units. Default each.
priceCentsinteger0 to 2,147,483,647. Default 0.
supplierIdstring (UUID) | nullA supplier of this storage. An ID that isn’t one of the storage’s suppliers is ignored (the item is created without a supplier) and the response gets warnings: [{ code: "SUPPLIER_NOT_FOUND", field: "supplierId", message }].
costCents, location, tags, customFieldsAs in the Item. customFields takes field IDs (or names); required fields must have a value when you send it.
barcodesstring[]Up to 10. When sent, it’s authoritative: barcode becomes barcodes[0].
trackBatchesbooleanTrack stock in batches. batch: { code, expiresOn } names the batch for the initial quantity.
kitobject | null{ stocked: true, components: [{ itemId, quantity }] } (1–50 components of this storage, no cycles).
Shell
curl -X POST "https://api-production-c3ca.up.railway.app/api/v1/items" \
  -H "Authorization: Bearer $INVENTRACKR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Espresso beans",
    "barcode": "8714789120045",
    "quantity": 12,
    "minimumQuantity": 5,
    "unit": "kg",
    "priceCents": 1899,
    "supplierId": "9b2e7c44-1f0a-4d3b-8e6f-5a1c2d3e4f50"
  }'

Returns 201 Created with the new Item and sends an item.created webhook. Unknown fields are ignored.

Update an item

PATCH/api/v1/items/{id}Write key

A partial update: send only the fields to change, including the new ones (cost, location, barcodes, tags, custom fields, batches, kit). Omitted fields stay as they are; customFields, when sent, replaces the whole map. Optional extras:

Extra fields
FieldTypeRules
versionintegerThe version you last read. If the item changed since, the update is refused with 409 VERSION_CONFLICT.
reasonstringWhen the update changes quantity: the stock reason (default other).
notestringWhen the quantity changes: up to 280 characters.
Shell
curl -X PATCH "https://api-production-c3ca.up.railway.app/api/v1/items/3f6c2a8e-6b1d-4c1e-9a52-2d8f0c7b9e10" \
  -H "Authorization: Bearer $INVENTRACKR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"version": 7, "location": "Aisle 4 / A1", "tags": ["Coffee"]}'

Returns 200 with the updated Item. An unknown supplierId is refused with 400 SUPPLIER_NOT_FOUND. A large stock decrease under the storage’s approval rules gets 409 APPROVAL_REQUIRED.

Delete an item

DELETE/api/v1/items/{id}Write key

Returns 204 No Content, 404 NOT_FOUND, or 202 with { "status": "pending_approval", "requestId" } when the storage requires approval for deletions. Sends an item.deleted webhook once deleted.

Change stock

PATCH/api/v1/items/{id}/quantityWrite key

Send either an absolute quantity or a relative delta (if both are sent, quantity is used), ideally with a reason:

Request body
FieldTypeRules
quantitynumberSets the stock: 0 to 999,999,999,999, at most 3 decimals.
deltanumberAdds to the stock (negative removes): −1,000,000 to 1,000,000, at most 3 decimals. The result never goes below 0.
expectedQuantitynumberOptional, with either form: the change is refused with 409 STOCK_CHANGED unless the current stock equals this value. Use it to avoid overwriting a count someone else just changed.
reasonstringOptional: received, sold, used, damaged, expired, lost, returned, count, transfer_in, transfer_out, kit or other (default). Reports use it.
notestringOptional, up to 280 characters. Shown in the activity history and included in the webhook.
unitstringOptional: the unit your amount is in. If the item’s unit is different, the change is refused with 409 UNIT_CHANGED.
batchIdUUIDBatch items only. Stock out: take from this batch first (then first-expiring first). Stock in: add to it. 409 BATCH_NOT_FOUND if it doesn’t exist.
batchobjectBatch items, stock in: { code, expiresOn } adds to that batch (created if needed).
unitCostCentsintegerStock in: the incoming unit cost. With reason received it updates the moving-average costCents.
Remove 2 kg
curl -X PATCH "https://api-production-c3ca.up.railway.app/api/v1/items/3f6c2a8e-6b1d-4c1e-9a52-2d8f0c7b9e10/quantity" \
  -H "Authorization: Bearer $INVENTRACKR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"delta": -2, "reason": "sold", "note": "Sold at the counter"}'
Set a counted value, only if nobody changed it meanwhile
curl -X PATCH "https://api-production-c3ca.up.railway.app/api/v1/items/3f6c2a8e-6b1d-4c1e-9a52-2d8f0c7b9e10/quantity" \
  -H "Authorization: Bearer $INVENTRACKR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"quantity": 40, "expectedQuantity": 3.5, "reason": "count", "note": "Stock count"}'

Returns 200 with the updated Item plus previousQuantity, reason, delta and batchMovements, and sends an item.quantityChanged webhook (and item.lowStock when the change takes the item from above its minimum to at or below it). Decreases stop at 0; batch items lose stock first-expiring first. Under the storage’s approval rules it can answer 202 pending approval instead.

200 OK
{
  "id": "3f6c2a8e-6b1d-4c1e-9a52-2d8f0c7b9e10",
  "name": "Espresso beans",
  "description": "House blend, 1 kg bags",
  "barcode": "8714789120045",
  "quantity": 1.5,
  "minimumQuantity": 5,
  "unit": "kg",
  "priceCents": 1899,
  "supplierId": "9b2e7c44-1f0a-4d3b-8e6f-5a1c2d3e4f50",
  "supplierName": "Roastery Co.",
  "hasImage": false,
  "imageVersion": 0,
  "version": 8,
  "createdAt": "2026-10-02T14:05:11.482Z",
  "updatedAt": "2026-11-18T10:02:44.590Z",
  "stockStatus": "lowStock",
  "costCents": 1150,
  "stockValueCents": 4025,
  "retailValueCents": 6647,
  "location": "Aisle 3 / B2",
  "barcodes": [
    "8714789120045",
    "BEANS-1KG"
  ],
  "tags": [
    "Coffee",
    "Bar"
  ],
  "customFields": {
    "5d0c9a1e-7b3f-4e2a-8c6d-1f2e3a4b5c6d": "Brazil"
  },
  "trackBatches": true,
  "batches": [
    {
      "id": "c1d2e3f4-a5b6-4c7d-8e9f-0a1b2c3d4e5f",
      "code": "L42",
      "expiresOn": "2027-03-31",
      "quantity": 3.5,
      "receivedAt": "2026-11-02T10:00:00.000Z",
      "costCents": 1150
    }
  ],
  "kit": null,
  "onOrderQuantity": 10,
  "previousQuantity": 3.5,
  "reason": "sold",
  "delta": -2,
  "batchMovements": [
    {
      "batchId": "c1d2e3f4-a5b6-4c7d-8e9f-0a1b2c3d4e5f",
      "code": "L42",
      "expiresOn": "2027-03-31",
      "delta": -2
    }
  ]
}

Suppliers

GET/api/v1/suppliersRead or write key

Shell
curl "https://api-production-c3ca.up.railway.app/api/v1/suppliers" \
  -H "Authorization: Bearer $INVENTRACKR_API_KEY"

Returns 200 with an array of the storage’s suppliers, sorted by name. Add ?limit= to page (see Pagination).

200 OK
[
  {
    "id": "9b2e7c44-1f0a-4d3b-8e6f-5a1c2d3e4f50",
    "name": "Roastery Co.",
    "contactName": "Sam Rivera",
    "contactEmail": "orders@roastery.example",
    "contactPhone": "+1 555 0100",
    "createdAt": "2026-09-14T08:12:40.019Z",
    "email": "orders@roastery.example",
    "phone": "+1 555 0100",
    "notes": "Net 30",
    "leadTimeDays": 7,
    "currencyCode": null
  }
]

POST/api/v1/suppliersWrite key

Body { name, contactName?, contactEmail?, contactPhone?, leadTimeDays?, notes?, currencyCode? } → 201 Supplier.

PATCH/api/v1/suppliers/{supplierId}Write key

A partial update with the same fields → 200 Supplier, or 404 NOT_FOUND.

DELETE/api/v1/suppliers/{supplierId}Write key

Returns 204. Its items lose the supplier (their version and updatedAt change) and each sends an item.updated webhook.

Purchase orders

GET/api/v1/purchase-ordersRead or write key

Query status (open = sent or partly received, draft, sent, partially_received, received, cancelled), supplierId and limit (≤ 500). Returns summary rows { id, number, status, supplierId, supplierName, currencyCode, expectedOn, createdAt, updatedAt, sentAt, receivedAt, version, lineCount, totalCents }, newest first.

GET/api/v1/purchase-orders/{poId}Read or write key

Returns the full order: number (PO-0001), status, supplier, dates, lines with quantity, receivedQuantity, remainingQuantity and unitCostCents, totals, and receipts. Orders are created and received in the app.

Stock counts

GET/api/v1/countsRead or write key

Counting sessions, newest first (?limit ≤ 200): { id, name, status, scope, assigneeIds, createdByName, createdAt, appliedAt, lineCount, countedCount, … }. Status is open, pending_approval, applied or cancelled.

GET/api/v1/counts/{countId}Read or write key

The session plus lines: each item’s expectedQuantity, movementsSinceSnapshot, expectedAtCount, countedQuantity, variance and varianceValueCents.

Reports

GET/api/v1/reports/{name}Read or write key

JSON reports, the same as in the app. Money is in cents; periods take from and to as YYYY-MM-DD (inclusive, UTC, at most 2 years).

Reports
nameQueryContents
stock-valuefrom, to (default 90 days)Cost and retail value in total and by supplier, tag and location, plus daily history.
movementsfrom, to (default 30 days)In and out by reason and by day.
shrinkagefrom, to (default 90 days)Damaged, expired and lost, by item and over time.
dead-stockdays = 30, 60, 90, 180 or 365Items with stock and no outbound movement in that time, and the value tied up.
abcdays = 30, 90, 180 or 365Items ranked by outbound value: A (top 80 %), B (next 15 %), C (the rest).
at-riskItems expected to run out before the next delivery could arrive.
expiringdays (default: the storage setting)Expired batches and batches expiring within the window.
purchasesfrom, to (default 90 days)Orders and received spend by supplier.

Audit log export

GET/api/v1/activity/exportRead or write key

The storage’s whole activity history, oldest first, streamed. Query: format (csv default, or json), from and to (date or date-time), userId, itemId, reason and type (comma-separated event types). Columns: id, createdAt, type, entityType, entityId, itemName, actorUserId, actorName, reason, delta, quantity, previousQuantity, note, payload.

Hook subscriptions

REST-hook subscriptions for automation tools: a hook is an ordinary webhook endpoint created with an API key instead of in the app. Deliveries, signatures, retries, auto-disable, replay and sequence work exactly as for webhooks.

GET/api/v1/hooksRead or write key

Lists the hooks created through the API: [{ id, url, events, enabled, source, createdAt }]. Webhooks added in the app aren’t listed.

POST/api/v1/hooksWrite key

Request body
FieldTypeRules
urlstring, requiredYour endpoint: https on a public host, else 400 WEBHOOK_URL_INVALID. targetUrl and target_url are accepted too.
event or eventsstring or string[]One or more event types.
sourcestringzapier (default) or make. Shown to the storage owner.
Shell
curl -X POST "https://api-production-c3ca.up.railway.app/api/v1/hooks"   -H "Authorization: Bearer $INVENTRACKR_API_KEY"   -H "Content-Type: application/json"   -d '{ "url": "https://hooks.example.com/abc123", "event": "item.lowStock", "source": "make" }'

Returns 201 with { id, url, events, enabled, source, createdAt, secret }. The signing secret (whsec_…) is shown only once. A storage can have up to 50 API hooks (409 TOO_MANY_HOOKS); they don’t count toward the 10 webhooks of the app.

DELETE/api/v1/hooks/{hookId}Write key

Returns 204, or 404 NOT_FOUND when the hook is already gone (treat that as success). Webhooks added in the app can’t be deleted here.

Sample events

GET/api/v1/samples/{event}Read or write key

Up to limit (default 3, at most 25) delivery envelopes of that event type, newest first, in the same shape as a webhook delivery. Recent real events (last 72 hours) come first; when there are none, samples are built from the storage’s current data, with ids sample:<type>:<id> and sequence: null. An unknown type returns 404. Automation tools use it to show example fields.

Webhooks

Webhooks send a signed HTTPS POST to your endpoint when products, stock, suppliers, purchase orders, transfers, counts or approvals change, whoever made the change and wherever it was made.

Setting up

  1. In the web app, open the storage, then Storage settings → Integrations → Webhooks (storage owner, Pro).
  2. Enter your endpoint URL and choose the events to receive.
  3. Copy the signing secret (whsec_…). It’s shown only once; to get a new one, rotate it.
  4. Select Send test to check your endpoint, then watch Deliveries for results.

Endpoint URLs must:

  • start with https:// (plain HTTP isn’t allowed) and be at most 2,000 characters;
  • not contain a user name or password;
  • point to a public internet host: not an IP address or hostname in a private, loopback, link-local, carrier-grade NAT, multicast or reserved range, and not a single-label name or a name ending in .localhost, .local, .internal, .localdomain, .home.arpa, .intranet, .lan or .corp.

The host is resolved when you add the webhook and again on every delivery; if any address it resolves to isn’t public, the delivery fails. A storage can have up to 10 webhooks.

Event types

Webhook event types
EventSent whendata
item.createdA product is added (in the apps, by CSV import, or with POST /items).item: the full Item
item.updatedA product’s details are edited in the apps or updated by a CSV import.item: the full Item after the change
item.deletedA product is deleted.item: { id, name }
item.quantityChangedStock changes: adjustments, edits of the count, CSV import, or PATCH …/quantity.item (after the change), previousQuantity, delta, and note when one was given
item.lowStockA stock change takes a product from above its minimum to at or below it.item: the full Item
supplier.createdA supplier is added (in the apps or by CSV import).supplier: the full Supplier
supplier.updatedA supplier is edited.supplier: the full Supplier
supplier.deletedA supplier is deleted.supplier: { id, name }
batch.expiringSoonA batch enters the storage’s expiry warning window (once per expiry date; daily at 06:00 UTC).batch: { id, code, expiresOn, quantity, daysLeft }, item
batch.expiredThe day after a batch expired (once).Same as batch.expiringSoon
purchaseOrder.createdA purchase order is created.purchaseOrder: the full order
purchaseOrder.sentA purchase order is sent (emailed or marked sent).purchaseOrder, emailed
purchaseOrder.receivedStock is received on a purchase order (every receipt, partial or full).purchaseOrder, receipt { id, lines, valueCents }, fullyReceived
transfer.completedStock moves between two storages (sent to both).transfer, with direction relative to the receiving storage
count.completedA stock count is applied.count: { countId, name, linesCounted, adjustments, varianceValueCents, items }
approval.requestedAn action is held for approval.request: { id, kind, status, payload, summary, requestedByName, … }
approval.resolvedA request is approved, declined, withdrawn or fails.request with its final status

An edit that changes the count sends both item.updated and item.quantityChanged; an edit that changes the unit sends only item.updated. Photo changes don’t send events. When a supplier is deleted, each of its products sends item.updated. item.lowStock fires on the crossing only: a stock change to at or below the minimum, a product created at or below its minimum, or a minimum raised to or above the current stock.

item.quantityChanged data also has the stock reason, and when relevant batches (batch movements), purchaseOrderId, transferId, countId, approvalRequestId, approvedBy and kitItemId.

Payload & headers

Every delivery has the same envelope:

Envelope fields
FieldDescription
idThe event ID (UUID). The same for every endpoint and every retry of this event: use it to drop duplicates.
typeThe event type, e.g. item.quantityChanged.
createdAtWhen the event happened (ISO 8601, UTC).
storageIdThe storage the event belongs to.
sequenceA number that increases with every event the storage produces. Use it to order events and to discard stale ones.
dataEvent-specific data (see the table above).
item.quantityChanged
{
  "id": "6f1c3e0a-2b7d-4f5e-9c1a-8d2e4b6a0f13",
  "type": "item.quantityChanged",
  "createdAt": "2026-11-18T09:31:27.214Z",
  "storageId": "b4a7d2c1-5e6f-4a3b-9c8d-7e6f5a4b3c2d",
  "sequence": 18342,
  "data": {
    "item": {
      "id": "3f6c2a8e-6b1d-4c1e-9a52-2d8f0c7b9e10",
      "name": "Espresso beans",
      "description": "House blend, 1 kg bags",
      "barcode": "8714789120045",
      "quantity": 1.5,
      "minimumQuantity": 5,
      "unit": "kg",
      "priceCents": 1899,
      "supplierId": "9b2e7c44-1f0a-4d3b-8e6f-5a1c2d3e4f50",
      "supplierName": "Roastery Co.",
      "hasImage": false,
      "imageVersion": 0,
      "version": 8,
      "createdAt": "2026-10-02T14:05:11.482Z",
      "updatedAt": "2026-11-18T09:31:27.103Z",
      "stockStatus": "lowStock",
      "costCents": 1150,
      "stockValueCents": 4025,
      "retailValueCents": 6647,
      "location": "Aisle 3 / B2",
      "barcodes": [
        "8714789120045",
        "BEANS-1KG"
      ],
      "tags": [
        "Coffee",
        "Bar"
      ],
      "customFields": {
        "5d0c9a1e-7b3f-4e2a-8c6d-1f2e3a4b5c6d": "Brazil"
      },
      "trackBatches": true,
      "batches": [
        {
          "id": "c1d2e3f4-a5b6-4c7d-8e9f-0a1b2c3d4e5f",
          "code": "L42",
          "expiresOn": "2027-03-31",
          "quantity": 3.5,
          "receivedAt": "2026-11-02T10:00:00.000Z",
          "costCents": 1150
        }
      ],
      "kit": null,
      "onOrderQuantity": 10
    },
    "previousQuantity": 3.5,
    "delta": -2,
    "reason": "sold",
    "note": "Sold at the counter"
  }
}
item.deleted
{
  "id": "6f1c3e0a-2b7d-4f5e-9c1a-8d2e4b6a0f13",
  "type": "item.deleted",
  "createdAt": "2026-11-18T09:31:27.214Z",
  "storageId": "b4a7d2c1-5e6f-4a3b-9c8d-7e6f5a4b3c2d",
  "sequence": 18342,
  "data": {
    "item": {
      "id": "3f6c2a8e-6b1d-4c1e-9a52-2d8f0c7b9e10",
      "name": "Espresso beans"
    }
  }
}
supplier.updated
{
  "id": "6f1c3e0a-2b7d-4f5e-9c1a-8d2e4b6a0f13",
  "type": "supplier.updated",
  "createdAt": "2026-11-18T09:31:27.214Z",
  "storageId": "b4a7d2c1-5e6f-4a3b-9c8d-7e6f5a4b3c2d",
  "sequence": 18342,
  "data": {
    "supplier": {
      "id": "9b2e7c44-1f0a-4d3b-8e6f-5a1c2d3e4f50",
      "name": "Roastery Co.",
      "contactName": "Sam Rivera",
      "contactEmail": "orders@roastery.example",
      "contactPhone": "+1 555 0100",
      "createdAt": "2026-09-14T08:12:40.019Z",
      "email": "orders@roastery.example",
      "phone": "+1 555 0100",
      "notes": "Net 30",
      "leadTimeDays": 7,
      "currencyCode": null
    }
  }
}

Request headers:

Webhook request headers
HeaderValue
Content-Typeapplication/json
User-AgentInventrackr-Webhooks/1.0
Inventrackr-EventThe event type (also in the body), e.g. item.created.
Inventrackr-DeliveryThe delivery ID (UUID): unique per endpoint and event, unchanged across retries.
Inventrackr-Signaturet=<unix seconds>,v1=<hex HMAC-SHA256>, with a second v1 while a secret is being rotated; see below.

Verifying signatures

Check every request before trusting it. The Inventrackr-Signature header looks like this:

HTTP
Inventrackr-Signature: t=1763458287,v1=0f4c1e5b8a…(64 hex characters)
  1. Split the header on , and each part on the first = to get t (the time the delivery was sent, in Unix seconds) and v1 (the signature).
  2. Build the signed content: the t value, a period, and the raw request body exactly as received: `${t}.${rawBody}`.
  3. Compute an HMAC with SHA-256 over it, using your whole signing secret (including the whsec_ prefix) as the key, and hex-encode it (lowercase).
  4. Compare it with v1 using a constant-time comparison. For 24 hours after a secret rotation the header has two v1 values (new secret first, then the previous one): accept the request if any of them matches.
  5. Reject the request if t is more than a few minutes from your clock (5 minutes is a good tolerance), to stop replays. Each attempt, including retries, is signed with a fresh t.
Node.js (Express)
import crypto from "node:crypto";
import express from "express";

const secret = process.env.INVENTRACKR_WEBHOOK_SECRET; // "whsec_…", used exactly as shown
const TOLERANCE_SECONDS = 300;

/**
 * Checks an Inventrackr-Signature header ("t=<unix seconds>,v1=<hex>", with a second v1 during a secret
 * rotation) against the raw body. Any matching v1 is accepted.
 */
function verifySignature(rawBody, header, secret) {
  const parts = String(header).split(",").map((part) => {
    const index = part.indexOf("=");
    return [part.slice(0, index).trim(), part.slice(index + 1).trim()];
  });
  const timestamp = Number(parts.find(([key]) => key === "t")?.[1]);
  const signatures = parts.filter(([key]) => key === "v1").map(([, value]) => value);
  if (!Number.isInteger(timestamp) || !signatures.length) return false;
  if (Math.abs(Date.now() / 1000 - timestamp) > TOLERANCE_SECONDS) return false;

  const expected = Buffer.from(crypto
    .createHmac("sha256", secret)
    .update(`${timestamp}.`)
    .update(rawBody) // the exact bytes received, not re-serialized JSON
    .digest("hex"), "utf8");
  return signatures.some((signature) => {
    const candidate = Buffer.from(signature, "utf8");
    return candidate.length === expected.length && crypto.timingSafeEqual(candidate, expected);
  });
}

const app = express();

// Read the body as raw bytes for this route (before any JSON parser).
app.post("/webhooks/inventrackr", express.raw({ type: "application/json" }), (req, res) => {
  if (!verifySignature(req.body, req.get("Inventrackr-Signature") ?? "", secret)) {
    return res.status(400).send("Invalid signature");
  }
  const event = JSON.parse(req.body.toString("utf8"));
  res.sendStatus(204); // answer within 10 seconds, then do the work
  queueForProcessing(event); // your code: dedupe on event.id
});

app.listen(3000);
Python (Flask)
import hashlib
import hmac
import json
import os
import time

from flask import Flask, abort, request

SECRET = os.environ["INVENTRACKR_WEBHOOK_SECRET"].encode()  # "whsec_…", used exactly as shown
TOLERANCE_SECONDS = 300


def verify_signature(raw_body: bytes, header: str) -> bool:
    """Checks an Inventrackr-Signature header ("t=<unix seconds>,v1=<hex>", two v1 values during a
    secret rotation) against the raw body. Any matching v1 is accepted."""
    parts = [part.strip().split("=", 1) for part in header.split(",") if "=" in part]
    try:
        timestamp = int(next(value for key, value in parts if key == "t"))
    except (StopIteration, ValueError):
        return False
    if abs(time.time() - timestamp) > TOLERANCE_SECONDS:
        return False
    signed = f"{timestamp}.".encode() + raw_body  # the exact bytes received
    expected = hmac.new(SECRET, signed, hashlib.sha256).hexdigest()
    return any(hmac.compare_digest(expected, value) for key, value in parts if key == "v1")


app = Flask(__name__)


@app.post("/webhooks/inventrackr")
def inventrackr_webhook():
    raw_body = request.get_data()
    if not verify_signature(raw_body, request.headers.get("Inventrackr-Signature", "")):
        abort(400)
    event = json.loads(raw_body)
    queue_for_processing(event)  # your code: dedupe on event["id"], process asynchronously
    return "", 204

Responses & retries

Answer with any 2xx status within 10 seconds to acknowledge a delivery; the response body is ignored. Anything else is a failure: other status codes, redirects (they aren’t followed), timeouts, TLS or connection errors. Do slow work after responding.

Failed deliveries are retried with exponential backoff (±10% jitter), up to 8 attempts in total:

Retry schedule
AttemptSentAbout … after the first attempt
1Within seconds of the change—
21 minute after attempt 11 min
34 minutes after attempt 25 min
416 minutes after attempt 321 min
5About 1 hour after attempt 41 h 25 min
6About 4 hours after attempt 55 h 40 min
712 hours after attempt 617 h 40 min
8 (last)12 hours after attempt 729 h 40 min
  • After the 8th failed attempt the delivery is marked failed and isn’t retried. Deliveries still pending after 3 days are also marked failed.
  • If deliveries to an endpoint keep failing for more than 3 days with no success in between, the endpoint is disabled (the app shows “Disabled after 3 days of failed deliveries”). Events that happen while it’s disabled aren’t sent right away. Re-enabling it (or a successful Send test) replays the subscribed events it missed during the last 72 hours, each at most once.
  • Webhooks pause while the storage owner isn’t on Pro: no new events are queued and pending retries wait (up to the 3-day limit).

Duplicates & ordering

  • At-least-once: a delivery can arrive more than once (for example when your 2xx response was lost, or after a redelivery or replay). Store the event id and ignore ones you’ve already processed. Redeliveries and replays keep the original id and sequence.
  • No ordering guarantee: deliveries are sent in parallel, an endpoint can have several in flight, and retries can overtake later events. Use the envelope’s sequence and the item’s version (or updatedAt) to ignore data older than what you already have, or fetch the item with GET /items/{id} for its current state.
  • The item in an event is its state right after the change, not when the delivery arrives.

Test deliveries & logs

Send test delivers a webhook.test event right away, signed like any other delivery, attempted once and never retried. You can send up to 10 tests per minute per storage. You can’t subscribe to webhook.test.

webhook.test
{
  "id": "6f1c3e0a-2b7d-4f5e-9c1a-8d2e4b6a0f13",
  "type": "webhook.test",
  "createdAt": "2026-11-18T09:31:27.214Z",
  "storageId": "b4a7d2c1-5e6f-4a3b-9c8d-7e6f5a4b3c2d",
  "sequence": 18342,
  "data": {
    "message": "This is a test delivery from Inventrackr."
  }
}

Deliveries shows the 50 most recent deliveries for a webhook with their status (pending, succeeded, failed), attempts, your endpoint’s HTTP status or the error, and the next retry time. Delivery logs are kept for 30 days.

Managing endpoints

The storage owner manages webhooks in the app (Pro). Endpoints can be changed in place instead of being deleted and added again:

  • Edit: change the URL or the events, or turn the endpoint off and on. Turning it back on queues the subscribed events it missed while off (at most the last 72 hours, never twice).
  • Rotate secret: issues a new signing secret, shown once. The previous secret keeps working for 24 hours, during which every delivery carries both signatures, so you can switch without dropping events.
  • Redeliver: sends a past delivery again with the same event id, sequence and body (up to 30 per minute).

Webhooks created by integrations show their source (for example app).

Zapier & Make

Both connect with an API key (a write key for actions) and use the hook subscriptions above, so events arrive in real time.

Zapier app
What
TriggersItem low on stock, Item quantity changed, New item, Purchase order received, Stock count completed
ActionsAdjust stock (by item or barcode; change or set; reason and note), Create item
SearchesFind item by barcode (with find-or-create)

Make: there’s no app to install; use the generic modules.

  • Trigger: add Webhooks → Custom webhook and copy its URL. Subscribe it once with an HTTP → Make a request module: POST https://api-production-c3ca.up.railway.app/api/v1/hooks with {"url": "<make url>", "event": "item.lowStock", "source": "make"}, or add the URL in the app under webhooks. Delete it with DELETE /hooks/{id} when you retire the scenario.
  • Actions: call the endpoints above with HTTP → Make a request and the Authorization header, for example PATCH /items/{id}/quantity, POST /items or GET /items?barcode=…. Send an Idempotency-Key (such as the execution id) so retries never apply twice.
  • Signatures: deliveries are signed like every webhook. To check them, compute HMAC-SHA256(secret, t + "." + rawBody) and compare it with each v1 value (details).

CORS & browser use

The API allows cross-origin requests from any origin (Access-Control-Allow-Origin: *) without cookies or credentials. Browsers may send the Authorization and Content-Type headers, can read Retry-After, and cache preflight responses for 10 minutes.

Limits at a glance

Limits
WhatLimit
API keys per storage25
Webhooks per storage10 in the app, plus 50 API hooks
Requests per API key120 per minute
Requests per IP address600 per minute
Items per page500 (default 100)
Request body256 KB
Webhook response time10 seconds
Webhook attempts8 over about 30 hours
Webhook replay window72 hours
Webhook redeliveries30 per minute
Idempotency keys1–120 characters, kept 24 hours per API key
Test deliveries10 per minute per storage
Delivery log50 most recent per webhook, kept 30 days

Versioning & changelog

The version is part of the path: /api/v1. Within v1 you should expect additive changes, such as new fields in responses and webhook payloads, new endpoints and new event types, so ignore fields you don’t know. A change that would break existing integrations would come as a new version. The machine-readable description is at inventrackr.com/openapi.json (OpenAPI 3.1), for client generators and API tools.

Changelog

  • : GET /me, REST-hook subscriptions (/hooks) and /samples/{event} for Zapier and Make.
  • : items gain cost, value, location, barcodes, tags, custom fields, batches, kits and on-order quantity; suppliers gain lead time, notes and currency. New endpoints: storage, item update and delete, item image, supplier writes and paging, purchase orders, counts, reports and audit export; item filters and deletion tombstones. Idempotency-Key on every write, a code on every error, rate-limit headers, approvals (202). Webhooks: sequence, secret rotation, endpoint editing with replay, redelivery and nine new event types.
  • : API v1 and webhooks documented publicly: items (list, get, create, change stock), suppliers (list), eight webhook event types, signed deliveries with retries, and the OpenAPI 3.1 spec.

Questions or something missing? Email support@inventrackr.com.