API docs
Sous Chef Management API
Request access

Changelog

Changes to the Management API contract, newest first.

Evolution here is additive: new optional fields and new operations may be added at any time. A client that ignores fields it does not recognise keeps working across the entries below.

2026-11: Webhook signatures also arrive as X-SousChef-* headers

Every signed webhook delivery now carries X-SousChef-Signature and X-SousChef-Timestamp, with exactly the same values as X-OneTablet-Signature and X-OneTablet-Timestamp.

  • Nothing to change. X-OneTablet-Signature and X-OneTablet-Timestamp stay on every delivery, and their values, the schemes, the JWT issuer and the JWKS URL are unchanged.
  • New integrations should read X-SousChef-Signature; Verifying webhook signatures now shows it. An integration can switch at any time, because both headers carry the same value.

2026-11: A page cursor remembers the first page's filters

page.cursor carries the filters and sort of the page it came from, on every paged read.

  • Send the cursor on its own, as Pagination describes. Every later page is the same query as the first, including a createdAtStartDate window.
  • Repeating the same filters (and sort) with the cursor works as before.
  • A page that sends only some filters (for example just sort) keeps the rest from the cursor, as long as each one you send equals the cursor's.
  • A filter sent with a different value from the one in the cursor is a 400.
  • A cursor you already hold is still accepted. It carries no filters, so it behaves as it did.
  • A cursor that was edited or cut short is a 400.
  • A filter list too long to fit in a cursor (several hundred ids) cannot be handed back: send the complete, identical list again with the cursor on every page; the cursor alone is a 400.

Nothing in a request or a response changes shape. page.limit may still change between pages.

2026-11: Orders carry their store, cancellation, items and totals

New and optional on every order fetchOrders and fetchOrder return:

  • store is the storefront the order arrived through: its id (the id fetchStores reports), externalId (the storefront's code), the location and brand display names, and the platform slug.
  • cancellation is present on every order whose status is cancelled, and on no other: by (platform, kitchen or system), reason, at, and, when the kitchen cancelled, reasonCode with the same OrderCancelReason codes as order.cancelled.
  • details is what was ordered and what it cost: the platform's order id and short order number, placedAt, estimatedPickupAt, isPickup, isMerchantDelivery; subtotal, tax, tip, deliveryFee and total in cents; the items, each with its price and modifiers; and the promotions.

The field names and nesting are those of the order published in 2026-08. The guest's identity, the delivery address, the courier and free-text notes are not included. A field the platform did not send is absent, so older orders can carry fewer fields. fetchOrders and fetchOrder return the same fields for the same order. The order webhooks do not carry these fields.

2026-11: Order webhooks say more, and item availability is pushed

New and optional on every order:

  • estimatedReadyAt: when the kitchen expects the order to be ready, set when Sous Chef accepts it. It arrives on the order webhooks from order.created on.
  • rejectReason and rejectReasonCode: on order.rejected, why the order was rejected, in words and as an OrderCancelReason code (storeClosed, itemOutOfStock, kitchenBusy, other).

fetchOrders and fetchOrder do not return these three fields.

New and optional on order.cancelled: reasonCode, the same codes, set when the restaurant cancelled (by: kitchen) beside the free-text reason. A cancellation made in the kitchen reports by: kitchen.

New event: item.availability.changed. When a kitchen marks an item or modifier option out of stock or back in stock, every organization that owns the item and subscribed to the event gets one delivery, with the changed items in the ItemAvailability shape fetchStoreItems returns and the organization's stores at that kitchen. Subscribe your url to it with setAllWebhookSettings, so that you do not need to poll fetchStoreItems for availability changes. WebhookEventType gains the value.

2026-11: Modifier options carry an item id, and order webhooks are signed with v2

New and optional: MenuModifierOption.itemId, the id an order carries for a modifier option.

Order webhooks are signed with v2, except on the legacy webhook feed. See Verifying webhook signatures.

2026-10: fetchStoreHours reports your own weekly hours at a kitchen you do not own

If your brands cook in another organization's kitchen, your organization can set its own weekly hours for all of its brands there, in the Sous Chef portal (Working hours, on that location's card). They apply only to your brands at that kitchen: the kitchen's own hours and other organizations' brands are untouched, and a menu with its own hours keeps them. This API has no operation that reads or writes that schedule as such; it reports what the schedule does to your storefronts.

Once your organization has set those hours, fetchStoreHours reports them as regular on your storefronts there, exactly as the storefronts are published. A storefront whose active menus all carry their own hours still reports the union of those menus' windows. The kitchen's special dates still apply: a closure closes your storefronts, and a date that opens the kitchen opens each one only within the hours fetchStoreHours reports as regular for that storefront on that weekday. One special date carries one window, so on a weekday where those hours are split (say 11:00-14:00 and 17:00-22:00), a kitchen date whose window overlaps both reads closed. In fetchStoreMenus, a menu that uses the location's hours still reports followsLocationHours: true; published to one of those storefronts after you set your hours, its snapshot carries your hours in workingHours.

If you own the kitchen. setLocationHours still replaces your kitchen's weekly template, and every storefront that follows the template takes it. A storefront of another organization's brand stops following it once that organization sets its own hours at your kitchen, the way a menu with its own hours never followed it: the call no longer changes that storefront's weekly hours, and fetchStoreHours reports that organization's hours on it, not your week. Such a storefront's brand.id is not among your fetchBrands. If you check a setLocationHours call by comparing every storefront at the kitchen with the week you sent, expect those storefronts to differ; sending the week again does not change them. Your special dates still reach them, limited as described above.

Nothing was added to or removed from any schema, and nothing changes at a kitchen until an organization sets its own hours there.

2026-10: Uber Eats' own refusal of a promotion is a 400, with Uber Eats' reason

When Uber Eats itself refuses a createUberEatsPromotion call, for a limit only Uber Eats enforces (for example an unknown userGroup, or a budget period it does not offer), the call now fails with 400 instead of a 5xx. The response carries errorCode and subType bad_request.uber_eats_refused, and its message carries Uber Eats' own reason, shortened. Nothing is created. The 400 is final: fix the request, do not retry it unchanged.

Every other failure is unchanged, including the 400s that Sous Chef answers before the request reaches Uber Eats.

2026-10: Uber Eats promotions are available

The four Uber Eats promotion operations are available: fetchUberEatsPromotions, fetchUberEatsPromotion, createUberEatsPromotion and revokeUberEatsPromotion.

Promotions are available for Uber Eats storefronts only. createUberEatsPromotion spends money on a live storefront and is not idempotent, and a promotion cannot be changed after it is created, only revoked: read the operation's notes on retries before you write the calling code.

2026-10: When menu.publication.completed fires, and what its id is

The menu.publication.completed reference page says when the event fires and how its id is built. Nothing was removed or narrowed: the payload is still the MenuPublication that fetchMenuPublications returns, and no field, type or enum changed.

  • It fires each time a publication reaches a terminal state: completed, which can include failed stores (read data.stores[].status), or failed.
  • A publication cancelled while it is queued or publishing reads failed and sends the event. Cancelling one that had already failed sends nothing more; its failed event was already sent.
  • A publication where no storefront had a menu to publish completes at once, with an empty data.stores, and sends the event.
  • When Sous Chef retries the failed stores of a finished publication, the publication goes back to publishing. When it finishes again, a second event arrives with a new completedAt and a new id. Both are real events; keep the one with the later data.completedAt.
  • The id is built from the publication and the instant it finished. Its current form is <publicationId>:<completedAt>. It is not a UUID. Deduplicate on it as on every event, and read data.publicationId and data.completedAt rather than parsing it.

You subscribe as for any other event: put menu.publication.completed in newUrlEvents with setAllWebhookSettings. Each delivery is signed the same way as store.status.changed (v2).

2026-10: Menu publications follow each platform's own answer; publishedAt and failedAt are published

MenuPublicationStore has two new optional fields: publishedAt, when a store's publication succeeded, and failedAt, when it failed. Both are ISO-8601 UTC instants.

fetchMenuPublications decides each store's status from the delivery platform's own answer instead of the moment Sous Chef submitted your menu:

  • publishing lasts until the platform answers. A store waiting behind another publication to the same storefront reads queued until its turn, and a submission retried after a temporary error stays publishing instead of reading failed first.
  • DoorDash confirms each menu it takes live, so a DoorDash store reaches confirmed, with confirmationMode: confirmed. Until then the publication stays publishing. Every other platform still stops at acknowledged.
  • A store that is not connected to its delivery platform reads failed, and platformError says that nothing was sent to it.
  • A publication's completedAt is the exact time it finished.

No value was added to or removed from any enum. Publications recorded before this change keep the status they were given.

A platform answer that arrives more than about 60 minutes after the submit does not change a store already reported failed.

2026-10: wentLiveAt and liveAt are set-up times, not go-live times

Store.wentLiveAt on fetchStores and liveAt on fetchStore were described as "when the storefront went live", absent until go-live. They are now described as the time Sous Chef set the storefront up.

  • A storefront you provision with the Onboarding API's addBrandsToLocation gets the value when it is created, before it takes any order.
  • Older storefronts may carry the set-up time of their brand at that location, or the moment they were first switched on.

Names and types are unchanged.

Action needed. This entry changes what an existing field is documented to mean. If you read either field as "this storefront is selling", switch to fetchStoreStatuses, which reports whether a store is open or paused and whether its platform shows it online.

2026-09: MenuAssignment.snapshot is typed, and snapshotWithheld is published

snapshot on fetchStoreMenus was published as an untyped object. It is now MenuSnapshot: the menu document as it was sent to the delivery platform, with named shapes for its categories (MenuSnapshotCategory), items (MenuSnapshotItem), modifier groups and options (including nested modifiers), prices in integer cents, and weekly and special hours. The bytes returned are unchanged: snapshots are still returned exactly as recorded, so every field is optional, a few are nullable, and an older snapshot may carry a key the schema does not list. Ignore such a key. Note that snapshot.storeId is the delivery platform's id for the storefront, not the Sous Chef store id.

MenuAssignment.snapshotWithheld is new. It is true when a published snapshot exists but is larger than the 2 MB per-snapshot cap and was left out, so a missing snapshot no longer means two things: snapshot and snapshotWithheld both absent means no published snapshot exists for that assignment.

2026-09: Uber Eats promotion discount is typed, one branch per promoType

discount on createUberEatsPromotion and on every returned UberEatsPromotion is a union discriminated by its own promoType, with one named shape per mechanic: UberEatsFlatOffDiscount, UberEatsPercentOffDiscount, UberEatsBogoDiscount, UberEatsFreeItemDiscount, UberEatsMenuItemDiscount and UberEatsFreeDeliveryDiscount. Amounts are integer minor units. A create whose discount.promoType differs from the promotion's promoType is a 400.

2026-09: report.completed is declared and can be subscribed to

The report.completed webhook has a reference page of its own, filed under Reports, and setAllWebhookSettings accepts report.completed in newUrlEvents.

The event fires when a report you requested reaches a terminal state (ready or failed) and carries the Report object, so status, completedAt and error arrive with the delivery. It does not carry files: a downloadUrl is signed at read time with a 24-hour expiry and is a bearer credential, so it is not sent in a webhook body. Call fetchReport with the reportId when the event arrives. Polling fetchReport remains authoritative, so a missed delivery does not leave a report unreachable.

2026-09: Reporting refusals answer 4xx with a <category>.<reason> subType

A report request that is refused because of its input is answered with the 4xx that describes it.

The error body's subType (and errorCode, which carries the same value) is a two-part code, <category>.<reason>. The category always agrees with the HTTP status:

categorystatusmeaning
bad_request400the input fails a check specific to reporting
not_found404does not exist, or is not yours (the two are indistinguishable)
conflict409conflicts with the current state
unprocessable422well-formed, but refused by a business rule

The codes in use today:

  • unprocessable.report_unavailable: the (platform, type) is not available to your organization (every DoorDash type, for example). See fetchReportCoverage.
  • unprocessable.report_window: the period is longer than the type's windowConstraint allows, or ends later than its dataLag allows.
  • unprocessable.report_no_eligible_stores: no eligible connected storefront matches the request.
  • not_found.report: fetchReport for an unknown reportId, or one belonging to another organization.

If you branch on subType: the createReport refusals previously documented as report_unavailable, report_window and report_no_eligible_stores now carry the prefixed form. Match on the part after the ., or on both spellings. Branch on the status code for the category; branch on the reason for the detail. New reasons may be added under any category without notice.

2026-09: fetchReports lists your reports and fetchReport downloads one

fetchReports lists the reports of the organization your API key authenticates, newest requestedAt first. You can filter by statuses, platforms and types, and page with page (page.limit above 100 is a 400). List entries never carry files.

fetchReport returns one report by reportId. When the report is ready, each entry in files carries a signed downloadUrl that works for 24 hours without credentials, so treat it as a secret. expiresAt says exactly when it stops working. Every call signs a fresh URL: when one expires, call fetchReport again. The report is never regenerated for this. A reportId that does not exist and one that belongs to another organization both return the same 404.

2026-09: createReport requests a platform report for your organization

createReport requests one platform report (Uber Eats or Grubhub) for a date range and returns the Report before its files are ready. The report covers only the storefronts of the organization your API key authenticates, optionally narrowed by locationIds or storeIds (sending both is a 400). A (platform, type) that fetchReportCoverage does not list as available (including every DoorDash type), a scope that matches no eligible storefront, or a period outside the type's windowConstraint or dataLag is a 422 whose subType says which.

The Idempotency-Key header is accepted and has no effect: a retried createReport requests a second report. Treat a timeout as "may have succeeded" and check your reports before retrying.

2026-09: Report coverage is available and scoped to your organization

fetchReportCoverage reports only the platform report capabilities reachable through storefronts connected to the organization authenticated by your API key. It is never a network-wide catalogue: an organization with no eligible connected storefronts receives an empty coverage array, and a platform connected only to another organization is absent. The response is a small fixed matrix and is not paginated.

Use available, windowConstraint, dataLag, and notes to decide which report requests are valid before creating one. Platform and report type are open strings so new vendor capabilities can be added without a contract version change.

2026-09: x-mealco-tx-id is declared in the OpenAPI document

The responses did not change. The header was already on Management API responses. The OpenAPI document now declares it on every response of every operation, so a client generated from openapi.json gives you a typed accessor for it. If you already read it by name, no action is needed.

It is declared optional because a request whose JSON body is malformed is rejected before it reaches an operation. That response carries neither the header nor the txId field of the error body. Every response that reaches an operation carries it. See Errors and retries → Report a failure with its transaction id.

2026-09: store.status.changed fires on resume, and "reactivated" is not a trigger

store.status.changed is sent when a store is resumed, not only when it is paused. Both transitions arrive through the same event, with no separate subscription.

The resume payload is desired: { "state": "open" } and nothing else. pauseNote, pausedUntil and updatedAt are absent on a resume. updatedAt means "when the current pause began", which an open store does not have. If you persist these fields, clear them when state is open rather than keeping the last value you saw. observed, discrepancy and lastPolledAt are omitted on operator-driven pause and resume, because this event carries intent and those fields describe an observation.

A reactivated store does not send this event. The event is sent when a store is paused or resumed, and once when a discrepancy with its delivery platform appears. No field, type or enum member changed.

The event is sent on every status write, not only on a change. Pausing an already-paused store, or resuming an already-open one, sends it. Read the payload as the current state, and collapse repeats on data.desired.state if you need strict edge semantics.

2026-09: lastPolledAt is the timestamp on a store status

lastPolledAt is on every status that carries an observed block, and it is when that observation was taken. The derived discrepancy is as fresh as that observation. A discrepancy is a standing condition, so read it as true as of lastPolledAt and re-read to see whether it still holds. See Data freshness.

2026-09: fetchOrders sorting, a storeId filter, locationCode, and no window ceiling

The order feed is sorted, and you choose the direction. sort takes createdAtDesc (newest first, the default) or createdAtAsc. Ordering on this operation was previously unspecified. Ties on createdAt break on the order's id, so the ordering is total: while nothing is written, no page repeats a row and none skips one.

sort: "createdAtAsc" with page: { "limit": 1 } answers "my very first order", and with a storeId it answers it for one storefront.

storeId is a new filter. It narrows the feed to one storefront, by the Store.id fetchStores reports.

locationId is now locationCode, the short site code carried on every store's location. Both name one kitchen. An existing but empty kitchen now matches nothing instead of answering 404. locationCode and storeId are mutually exclusive. Sending both is a 400, because a storefront is already inside exactly one kitchen.

The 31-day ceiling on [createdAtStartDate, createdAtEndDate) is removed. Both bounds stay optional, and omitting both means all-time. There is no retention ceiling and no width ceiling. Narrower windows are still fine if your loader wants checkpoints.

The fetchOrders cursor stops at 10,000 orders, with a 400. Every order is still readable: a narrower [createdAtStartDate, createdAtEndDate) window reaches the same rows. This replaces the previous cap of 1,000 pages of 100 rows.

Nothing was removed from a response, and no existing value changed meaning. The one request-shape change is locationId → locationCode: if you wrote a call against locationId, send the code from the same store row instead of its location's id.

2026-09: fetchOrders filters on a creation-time window

fetchOrders filters on a time window. The parameters are createdAtStartDate (inclusive) and createdAtEndDate (exclusive), and they bound the order's creation time, the moment Sous Chef recorded it. At this date the two could be at most 31 days apart; that limit was removed later (see the entry above).

Send createdAtStartDate and createdAtEndDate, not from / to. from and to are not parameters of this operation.

Creation time, not pickup time. The window bounds when the order was created, not when it was picked up. If you are reconciling against a platform's own pickup-time export, expect the boundaries to differ by the order's lead time. There is no pickup-time filter.

Windowing on creation time is what makes a backfill exact: an order is created exactly once, so contiguous [createdAtStartDate, createdAtEndDate) windows partition your history with no gap and no overlap. There is no rolling retention ceiling, so a full warehouse load is a loop over windows with the cursor loop nested inside each one.

2026-09: Responses carry a transaction id

A response from an operation carries an x-mealco-tx-id header, on a 200 as well as on a failure, and error bodies carry the same value as txId. It is the identifier we use to follow one call end to end. Log it beside your own record of each request, and quote it when you contact support.

You may send your own x-mealco-tx-id on a request and we adopt it, so your correlation id and ours are the same string. It is a label only: it carries no authorization and no access of any kind. Do not put personal information in it.

Nothing changed in any existing field. The full rules (length limits, the responses that have no id, and what not to put in it) are under Concepts → API conventions.

2026-09: setAllWebhookSettings leaves an omitted field unchanged

A field you omit keeps its stored value, and a field you send is set. Previously setAllWebhookSettings was a full replace: every field you did not send was reset to a default.

This matters most for legacyUrlEnabled. If you do not send it, legacy delivery continues unchanged, so registering a newUrl without it does not switch the legacy order feed off.

Nothing you already send changes meaning. A call that states all four fields does what it did before. Only fields you leave out are affected.

Two details to design around.

newUrlEvents still replaces the whole list when you send it, and [] still means "no events". It is not an append. Omit it to leave the subscription list alone.

Omitting newUrl no longer clears the destination. To clear it, send newUrl: null explicitly. In most cases newUrlEnabled: false is the better choice: it stops delivery while keeping the registration. Clearing your only destination is refused with a 400.

The operation keeps its name. "Set all" means this one call covers all of the settable webhook fields, not that it resets the ones you leave out.

2026-08: The hours writes are owner-only

setLocationHours and setLocationSpecialHours write a locationId your organization owns: one whose Location.organizationId equals your own organization id. If you operate a brand out of another organization's host kitchen, fetchLocations shows you that kitchen and fetchStoreHours reports its hours, but you cannot make the hours writes there. Neither write is brand-scoped, so a single call moves the schedule for every brand trading at that location, including the host's. Ask the host to make the change.

The boundary did not change. Both operations were already owner-only, and a call that succeeded before still succeeds. The rule is documented on both operations, and a refused call answers 404.

The 404 is the same one you get for a locationId that does not exist, and the two are indistinguishable, so that locations you cannot see cannot be enumerated. Compare organizationId on the location from fetchLocations with your own organization id before you write, and treat a 404 on an id that fetchLocations returned as "that kitchen is not yours".

2026-08: setLocationHours makes the weekly template writable

setLocationHours replaces a location's regular weekly operating hours. Send the complete week as windows (one entry per open period, day plus opensAt and closesAt in HH:MM), and it replaces whatever the location had. Several entries may name the same day for a split service, and an entry whose closesAt is earlier than its opensAt crosses midnight, as fetchStoreHours reports them.

This completes the hours pair: setLocationSpecialHours writes the date-specific overrides, setLocationHours writes the weekly template underneath them, and fetchStoreHours reports the resolved result. The two tiers are independent: a weekly write never touches a special date, and a special-date write never touches the week.

Two things to design around.

windows is required and must be non-empty. There is no "clear the week" form, because an empty template would leave every menu at the location with no hours, which is a closure rather than an hours edit. Close a location with setLocationSpecialHours or the store-status pause operations.

This write republishes menus. Propagation reaches every storefront at the location whose menus follow location hours. A menu configured with its own hours is unaffected, and fetchStoreMenus reports which is which. Propagation is asynchronous, and it is a real publish: a menu holding unpublished saved changes goes live with them. The reply echoes what was persisted; read the settled, per-storefront result back from fetchStoreHours.

Superseded in part: once another organization sets its own weekly hours at your kitchen, its storefronts there stop taking this week. See the 2026-10 entry on your own weekly hours above.

A locationId that is not yours is a 404, indistinguishable from one that does not exist. This is the same convention as every other single-resource operation here. See the owner-only entry above for which locations count as yours.

2026-08: Webhook signatures are asymmetric under the v2 scheme

Store-event deliveries carry X-OneTablet-Signature: v2=<jwt>, a standard ES256 JWT you verify with a public key fetched from https://api.onetablet.com/.well-known/onetablet-webhook-jwks.json.

The delivery body is unchanged, byte for byte. The signature is detached: the token carries a body_sha256 claim over the raw bytes rather than wrapping the envelope, so nothing about the JSON you already parse has moved.

Why v2. v1 is HMAC under a shared secret, and a shared secret that lets you verify also lets you sign. Under v2 we hold the private key and you hold nothing that can produce a signature.

What changes for you: the replay window is nbf/exp, enforced by your JWT library instead of clock arithmetic in your code, and key rotation is a JWKS refresh that your library does on its own.

Match on the prefix. A delivery can carry more than one scheme, comma separated (v1=<hex>,v2=<jwt>), so find the v2= part rather than comparing the whole header. New integrations should implement v2 only.

For full details, the claim set and a Node example, see Verifying webhook signatures.

2026-08: Special hours are the location tier only

Special hours on this API are modelled at one tier, the location. They are written with setLocationSpecialHours and reported inside fetchStoreHours. There is no operation addressed by a brand-and-location pair.

2026-08: Store-event webhook deliveries are signed

Every store-event delivery carries X-OneTablet-Timestamp and X-OneTablet-Signature. Signing is mandatory on these deliveries: there is no opt-in, no per-endpoint flag, and no unsigned mode. The first scheme was v1, an HMAC-SHA256 over "<timestamp>." + <raw body>. v2 replaced it; see the entry above.

Verifying webhook signatures is a new page under Concepts, with the exact string being signed, a working Node example, and how rotation behaves. We strongly recommend that you verify signatures: a webhook url is not a secret, and without verification a forged POST is indistinguishable from ours.

This entry did not change order deliveries. See Verifying webhook signatures for which order deliveries are signed.

2026-08: Single-subject reads, and the order feed is available

Three new operations, each the single-item form of an existing list:

  • fetchOrder: get one order by its Sous Chef id. The read to make when an order webhook lands.
  • fetchStoreStatus: one storefront's desired / observed / discrepancy, identical in shape and in meaning to a row of fetchStoreStatuses.
  • fetchStoreItems: item availability addressed by storeId instead of locationId. It answers from the store's parent kitchen, narrowed to the store's brand, and echoes locationId so the kitchen grain is visible in the response. Availability is still a kitchen-level fact: every sibling storefront of that brand at that kitchen reports the same values.

fetchOrders returns orders. Filter by orderIds, locationId (now locationCode, see the 2026-09 entry above) and statuses, and page with the cursor.

The time-window filter, on the order's creation time, arrived in 2026-09. See the entry above.

2026-08: Store status is its own section, on its own path prefix

fetchStoreStatuses, pauseStores, unpauseStores and the store.status.changed webhook moved out of Stores into a new Store status section, and their paths moved with them:

WasNow
/management/stores/fetchStoreStatuses/management/store-status/fetchStoreStatuses
/management/stores/pauseStores/management/store-status/pauseStores
/management/stores/unpauseStores/management/store-status/unpauseStores

Nothing about the request or response bodies changed, and no other operation moved. Stores now covers the identity map and schedules (what you operate). Store status covers whether a storefront is currently taking orders, and whether Sous Chef and the delivery platform agree about it.

2026-08: Guide pages for webhooks, freshness, reports and coverage

Added Webhooks, Data freshness, Platform report catalogue and Platform coverage to Concepts, and a rate-limit section to Authentication. No contract change.

2026-08: fetchStoreStatuses

fetchStoreStatuses reports store status for one storefront or a whole estate in a single operation. Each status carries desired, observed and discrepancy separately, and lastPolledAt so that you can check the age of an observation before acting on it.

2026-08: Directory reads

fetchLocations, fetchBrands and fetchStores are the identity map, including the crosswalk from Sous Chef identifiers to each platform's own storefront identifier.

2026-08: fetchOrders

fetchOrders is the normalized order feed, with time-window, status and location filters, or explicit orderIds. Order webhooks are described in Webhooks.

2026-08: Management API published

The first version of the Management API was published.