NewStore offers self-checkout via a set of platform APIs that lets you build your own self-checkout experience for shoppers in your stores. It is a headless capability, NewStore provides the platform layer that makes self-checkout possible, and you or your integration partner build the frontend that shoppers interact with.
The APIs run on the same platform logic as Associate App, as the app uses the same APIs. Your self-checkout flow uses the same catalog, the same tax engine, and the same order pipeline as the rest of your NewStore-powered store operations. The orders placed via NewStore self-checkout are also available for further audit and management in Omnichannel Manager, the same as orders placed via Associate App.
APIs in Beta
The self-checkout APIs are in Beta stage and are subject to change. Validate your integration against the latest documentation before going live in production.
What NewStore offers
NewStore provides backend APIs for each step of a self-checkout transaction.
API | What it does |
|---|---|
Resolves a scanned barcode to a product, including its price and tax class. | |
Applies automatic promotions and coupon codes to the cart and returns the discounted price of every unit. | |
Calculates cart totals and taxes. This API is the source of truth for all amounts. | |
Places the completed transaction as an order in the NewStore platform. | |
Creates the receipt document for the shopper. |
Along with the APIs, NewStore provides:
Authentication: OAuth 2.0 with an Application client that you create in Omnichannel Manager and per-store credentials, so each self-checkout terminal operates on behalf of a store. See Authentication and setup for self-checkout.
Local development stub servers: A set of stub servers that mirror the real platform APIs, so you can build and validate your integration locally before you receive platform credentials. See Running self-checkout integration locally.
Integration documentation: A step-by-step guide through the complete transaction flow, including money handling rules and error scenarios. See the Self-checkout integration guide.
How a self-checkout transaction works
A self-checkout transaction follows five steps, in this order. Each step consumes the output of the previous step.
Catalog lookup: The shopper scans a barcode. The self-checkout app resolves it to a product and price using the Catalog API.
Promotions calculation: The self-checkout app submits the cart and any coupon code to the Promotions API, and receives the discounted price of every unit. You can choose to call the API after every change made to the cart or only when displaying the amount totals at the end of the flow.
Tax quotation: The self-checkout app requests totals and taxes from Tax Quotation API, which connects with your integrated tax provider. You can choose to call the API after every change made to the cart or only when displaying the amount totals at the end of the flow.
Order placement: The shopper pays through a payment terminal provided by you, and the self-checkout app places the order with the payment details using Order Placement API. To understand how payments work during order placement, see the Integrating payments for self-checkout.
Receipt creation: The self-checkout app creates the receipt for the shopper by calling the Receipt API.
What NewStore provides off-the-shelf and what you build
NewStore provides the platform APIs. You, or a system integrator working with your retail business, build and operate everything the shopper sees and interacts with.
NewStore provides | Retailer or your SI partner builds |
|---|---|
The self-checkout APIs, see What NewStore offers. | The self-checkout app frontend that the shopper interacts with, such as a web or mobile app running on a kiosk or tablet |
Authoritative tax and tax computation through your integrated tax provider (such as Vertex or Avalara) | The cart logic that carries products, quantities, and tax classes through the flow |
Promotion and coupon evaluation, with the discounted price of every unit | The coupon entry field on the kiosk and the display of the applied discounts |
Order management, including order records visible in Omnichannel Manager | The payment step and payment flow, integrating with your payment provider and terminal of choice. |
Receipt document generation, including a link to the receipt that you can present or send to the shopper. | The hardware setup for self-checkout, such as kiosks, tablets, scanners, and payment terminals. |
Authentication infrastructure and store-level credentials | Deployment and store operations procedures, such as the login process on each terminal at the start of the trading day. The API client configuration: redirect targets, allowed origins, and token lifetimes via Omnichannel Manager. |
Local stub servers and integration documentation | Monitoring and support processes for your frontend, in partnership with your system integrator or partner of choice. |
Who benefits from self-checkout
Shoppers complete their purchase on their own, without waiting for an associate on the floor.
Store associates spend less time on checkout and are available for other work on the store floor, including Clienteling in Associate App.
Retail IT teams and integration partners own the frontend, so they control branding, workflow and user journey design, and hardware choices end to end. NewStore provides the underlying commerce logic and a stable platform to operate on.
Limitations
Keep the following constraints in mind when planning a self-checkout project for your business.
No NewStore-supplied frontend or hardware: NewStore does not provide a self-checkout UI, kiosk, screen, or any hardware. The frontend is yours to build and operate.
No software development kit (SDK): The offering is a set of HTTP APIs. There is no client SDK available. You integrate directly against the provided API endpoints.
Basic sales transactions only: The current scope covers cash-and-carry sales. A single transaction with in-store handover can be processed at a time.
Important
Exchanges, returns, mixed carts, and split payments are not supported. The Receipt API creates sales receipts only.
Promotions at the kiosk: Automatic promotions and coupon codes are supported through the Promotions API. Manual discounts and price overrides are not available at the kiosk. A price override in the request comes back as a
manual_discount_forbiddenerror.Payment processing stays with your terminal: NewStore records the payment on the order but does not process it. Your frontend takes payment through to your payment terminal, with the payment provider of your choice, before placing the order.
Network connectivity: Self-checkout requires network connectivity. Unlike the Associate App, Offline Mode is unavailable.
Quick process decision on building with or without AI
To make a quick process decision on building the self-checkout app via AI or using our docs, click the image below to use an interactive decision tree.
Next steps
Work through the articles in this section in the order provided to test locally and then deploy self-checkout in a live environment.
Building self-checkout, with or without AI: Select how you build the app, with AI skills or from the documentation, and what each path needs.
Hardware prerequisites for self-checkout: Plan the kiosk, scanner, printer, and payment terminal.
Authentication and setup for self-checkout: Get credentials provisioned and implement the OAuth 2.0 flow.
Running self-checkout integration locally: Build against the local stub servers, with no credentials needed.
Integrating payments for self-checkout: Drive the payment terminal from a thin backend and record the payment on the order.
Self-checkout integration guide: Implement the full transaction flow, from barcode scan to receipt.
Tutorial: Setting up self-checkout in a store: Follow the complete setup for one store, from credentials to the first live transaction.