Changelog

The Order texts setting is now Order notifications. Turned off, it also stops Layout's placed push notification and the Live Activity in the Layout app for orders your application starts.

A connect return URL must be one you registered, a build grant reads only its own orders, and closing an account ends its connections.

CLI 0.5.0 adds layout check, which grades your integration from its last day of sandbox and tests your webhook handler, and runs test-order at real restaurants with any ending.

Uploading or removing the logo of an approved application now returns it to review, as renaming one already does.

A sandbox cart at a real restaurant is built from the menu Layout holds, with no browser, and reaches the ending you send as simulate. Sandbox places and menus cover only restaurants whose menu Layout holds.

On a full Layout account, a card link now lets the person replace any card on it, named on the page before they type, instead of ending on "No room for another card".

An item the restaurant serves already built now comes back that way, and orders no longer ask the person to pick what it already comes with.

A usual menu, scope "chain", now carries each item's optionGroups on POST /v1/menus and the MCP menu tool, with no price on any option.

For a location Layout has not read yet, POST /v1/menus and the MCP menu tool now answer at once with the restaurant's usual menu, scope "chain", instead of starting a read.

GET /v1/users/{userId} and verify now say whether a person has a card Layout can order with. GET /v1/places takes several names, the ids of places you picked, include=closed and ordering=confirmed.

A webhook subscription can receive sandbox events, production events or both. Events wait as held while an endpoint is unverified, and Layout checks it again on its own.

CLI 0.4.3 adds layout webhooks verify and layout refusals, an --environment flag on webhooks add, and reads of production keys and endpoints without login --live.

POST /v1/users/:id/links mints a single-use, 15-minute Layout page where a person you provisioned adds a card without signing in. card_required for that person no longer carries a url.

DELETE /v1/users/:id ends your application's link to a person, for every application. Their grants stop at once and their standing agreement ends; their Layout account is never deleted.

CLI 0.4.2 adds layout webhooks add and remove, masks the sandbox signing secret, takes --app by name, shows every sandbox allowance in layout usage, and runs every test restaurant in layout test-order.

Build sessions check store names as REST does, answer store_not_found, cancel a cart while it builds, take ord_ ids on every action, read carted and expired carts plainly, and answer grant_expired.

People can no longer ask Layout for a code on every order, so codeReason no longer has person_setting. The sandbox's test_place_code now reads risk_check.

Production is now requested from a full-screen form in the console that also writes your listing in the Layout connector marketplace. layout request-live-access answers with the console link instead of filing a request.

A good verify code now makes the person's own Layout account, for every application. Nobody is sent to a sign-up page, and confirms answer verify_required, not sign_up_required or link_expired.

A build session's carted build now carries the total the person pays, Layout's service fee included, and its confirm must send that total. Build sessions also order pickup only, and order_status says more.

wrong_credential, grant_expired, CART_EXPIRED on expired carts, stricter store names, provisioned_to_another_app, a real wait on every short 429, the standard 404, pickup details on order.updated, and stricter checks.

When a location's own menu cannot be read, POST /v1/menus and the MCP menu tool can answer with the restaurant's usual menu, marked with the new scope field and never priced.

POST /v1/menus now answers at once from a whole menu Layout read recently, with a new readAt field, and pricesUnavailable is true whenever the site gave no prices.

order.updated can now arrive more than once per order, one for each wave of pickup details, each with its own event_id. The pickup time often comes last; the sandbox restaurant test_place_pickup_later tests it.

A new Order texts setting on App details stops Layout's text that an order is placed, and the later text with the pickup time, for orders your application starts.

The page where a person you provisioned adds a card now shows your application's name and console logo, and tells them to go back to your application once the card is saved.

A new page tells a coding agent how to integrate Layout in sandbox and what a person does first. The quickstart, going to production and the CLI page were corrected where an agent would go wrong.

A stopped build's status now answers canceled right away instead of "still building".

POST /v1/carts/:id/confirm now refuses the restaurant's total alone with 400 invalid_request when Layout's fee applies. Send the cart's totalMinor, as the docs have always said.

The reference pages were corrected where they were wrong, stale or missing. A few corrections change what an integration should do; they are listed first.

The order read now carries the pickup name, store order number, instructions, lines and charged total. Carts say why a code is needed, and order.updated follows late pickup details.

GET /v1/places now lists only places open right now. The openNow parameter and the notOpenNow field are gone; a request that still sends openNow is answered, never refused.

A cart whose order is being placed now answers with that order's placement status instead of cart_expired, and a new build at the same store waits until the paying order lands.

The docs now say which location to send so Layout offers the store closest to the person: device coordinates first, an address turned into coordinates next, a city name last.

Create a CLI token in the console and set LAYOUT_CLI_TOKEN to run the CLI in CI or from a coding agent with no login. layout init sets an app up in one step, and layout listen needs no webhook endpoint.

A Layout button and guide for signing people in, hosted or on your own screens. Returning people skip a second approval, login_hint prefills the phone, and headless verify texts someone already connected.

GET /v1/orders/:id now carries ready_eta, the pickup time in the store's own words, once an order is placed.

layout login --live adds 12 hours of production reads, layout api calls any REST endpoint with your key, and LAYOUT_SECRET_KEY runs api and test-order in CI without signing in.

When a person connects your application, Layout now tells them it can place orders for them, and that connection is their agreement. A build grant's first order no longer needs a code of its own.

A confirm on a cart the person already confirmed, by replying YES to Layout's text or in the Layout app, now answers 409 already_confirmed with the order and its real state, over REST and MCP.

A cancel on a building cart is now accepted as canceling and sends no cart-ready text. A placeId and restaurantName that disagree answer store_mismatch. Store addresses ride everywhere.

A build grant needs the person's code until they approve an order through your application with it, then only when Layout would ask for one anywhere else. A build_only refusal now names the missing step in error.next.

A build grant can read the orders its application built for that person, whoami lists each scope once, and a fired test webhook names the sandbox order it described.

A command line tool that signs in to your developer account and works in sandbox. Create an app and a sandbox key, forward webhooks to your machine and run a test order, by hand or from a coding agent.

Create a sandbox account that signs in on Layout's consent screen, so you can test your OAuth client end to end with simulated orders. No email to Layout, no real order, no card.

Your hourly and daily room for verification and approval texts now grows with the people you have verified, Layout's shared hourly ceiling is 2,000, and GET /v1/usage shows your number and where it grows next.

Every REST endpoint's answer names the dated API version that answered and carries an X-Request-Id. Pin a version with the Layout-Version header. The versioning policy gives at least 180 days' notice.

Order previews now carry a single outcome field, a lone branch on the street someone named resolves without a question, and a menu read refused as too soon says when to try again.

Your developer account can run 250 sandbox builds a day across all its apps, on a counter of its own. Every sandbox refusal now names the limit that stopped it and how to get past it.

A build grant can now confirm a live order. Layout texts the person a code that names the total, the store and the card, they give it to you, and you send it on the same confirm. Over REST and MCP.

A refusal by a daily ceiling now names the ceiling in error.limit, with its scope, number and reset time. The MCP order tool returns the same as refusal.

The docs now tell one story for REST and MCP, list every error code and failure code, describe the webhook payload exactly, and publish every MCP tool's input and output schema.

A new webhook endpoint now turns on once it answers a signed verification event with a 2xx, and you can rotate a signing secret with 24 hours in which both the old and new secrets sign every delivery.

Webhook payloads carry a stable event_id, an occurred_at time and, on order.failed, a failure_code. GET /v1/events resumes from an event id and filters by order, person, type and time.

A sandbox build can now be confirmed. The confirm is simulated, so no restaurant receives it and nothing is charged, and your webhooks and order reads say so with simulated set to true.

Changes that affect your integration get an entry here, published once they are live, with an Atom feed and Markdown for agents.

Show what a menu item looks like, from the photo the restaurant itself published. POST /v1/images/items finds one item's photo, and every /v1/menus item Layout already holds a photo for now carries it.

The MCP's ordering tools are now REST endpoints. Find a place, read its menu, build a cart, confirm it, and read the order, with the same two ways in as MCP.

Production limits on provisioning, build sessions, texts and requests are much higher, one calling address no longer caps a busy backend, build grants refresh, and GET /v1/usage shows every limit and your usage.

Create OAuth clients for an app where people sign in with their own Layout account. The orders they place through your client reach your webhooks, the events feed and GET /v1/orders/:id.

Search places, read one place, and read a live menu over REST for a person you are connected to, with the same answers the MCP tools give. The OpenAPI spec is now generated from the shapes the API validates with.

POST /v1/orders still answers 410, now with the code use_carts and a message that points to POST /v1/carts. It used to send moved_to_mcp.

Every REST POST now takes an Idempotency-Key header. A retry with the same key and body gets the stored response for 24 hours and never runs twice.

Revoke a person's connection with RFC 7009, ask for the REST API and MCP in one authorization, and read a real WWW-Authenticate on a refused person credential. A disconnect now stops MCP tokens on the next request too.

The codes Layout texts a person now only verify a number or approve one order. A production headless verify connects your application and nothing else, and sandbox and unapproved traffic draws on limits of its own.

Sandbox test restaurants script one outcome each, from a ready cart to a declined or unconfirmed order, and never reach a real restaurant. A new endpoint fires a signed test webhook at your sandbox endpoints.

When nobody confirms a ready cart, Layout texts it to the person so they can reply YES. If your own chat carries the confirm, you can now turn those texts off for your application.

The order.challenge webhook is now sent, MCP results carry the ord_ id your REST calls use, and the MCP reference now says how long build waits.

Sandbox builds never ask for a card. Each application has its own daily sandbox allowance, and a new Usage page shows what you have used and lets you ask for more.

A new Orders page lists every order your keys caused in the selected environment, with the outcome in words and the reason when one did not complete.

A disconnected person can be invited again, sandbox answers next: "connect" where production would text an approval link, and order.needs_approval and order.challenge are marked as not sent yet.

Sandbox and production deliveries are now signed with different secrets, and every delivery says which environment it came from. Production verification needs the new production secret.

GET /v1/whoami says which application and environment a key opens and whether production is approved, so going live is a check instead of a 403.

A person's connection to your app now survives them signing in to Layout. People who already have Layout can connect by approving you, and Layout texts them the approval link itself.

Two new calls let a provisioned person prove their phone without opening a Layout page. Layout texts them a code, they read it to you, and you pass it back.

POST /v1/orders is retired and answers 410. Carts are built over MCP with a build grant, and a build grant session now lists only the three tools it can use.

Someone you just provisioned can see a real, priced cart before they have a card on file, up to a daily allowance set for your application. When a card is needed, Layout's card page names your app.

Search that reads every page, an endpoint reference, three new guides, and the whole reference as llms.txt, Markdown twins and an OpenAPI 3.1 file.

Client secrets can be revealed on demand instead of once at creation, the console says what your approval status allows, logos upload as files, and application ids take a new form.

Send test event fires a real, signed delivery at your endpoint, so you can prove the whole path before a single order exists.

The API still answers every refused key with the same sentence. Your console now shows the real reason, which key it was, how many times, and when it last happened.

Sign up, create an application and build against sandbox the same day. Provision a person, build a real cart for them, and follow every order on signed webhooks.

When a person connects an MCP client to Layout through OAuth, the consent screen shows that client's logo beside the Layout mark, drawn from the host its redirect URI points at.