NewStore self-checkout is headless. NewStore provides the platform APIs, per-store credentials, documentation, and local stub servers. You, or a system integrator (SI) working with you, build the self-checkout app that shoppers use, take payment through your own payment terminal, and oeprate the self-checkout lane in the store. See Self-checkout via NewStore.
NewStore provides two ways to build the self-checkout app:
Path 1: Building with AI skills. Use the NewStore self-checkout plugin with an AI coding assistant. The skills interview you in business language, build the app against the documented APIs, and hand it over with a list of open items.
Path 2: Building from the documentation. A developer or SI builds the app directly from the four implementation articles in this section and the API specifications.
Both paths produce the same result: a self-checkout app for the kiosk, as a web, desktop or native app, and a small backend for payments, integrated with the Catalog, Promotions, Tax Quotation, Order Placement, and Receipt APIs. For each path, this article lists what you need, where NewStore helps, and what you do yourself.
APIs in beta
The self-checkout APIs are in beta and can change. On either path, validate the app against the Self-checkout integration guide and the API specifications before you go live in production.
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.
What is the same on both paths
Whichever path you select, the following does not change:
NewStore does not supply a frontend, hardware, or a software development kit (SDK). See Limitations.
You create the API client yourself in Omnichannel Manager. NewStore support creates the per-store credentials and might take time, so raise the ticket on the first day. See Requesting self-checkout credentials.
Payment stays with your Payment service provider (PSP) and terminal. The PSP API key stays in a thin backend that you own, never in the browser. See Integrating payments for self-checkout.
Hardware is yours to select, buy, and operate. See Hardware prerequisites for self-checkout.
The app runs against your staging tenant before production, and the store manager logs in on each terminal every morning. See Going live and Operating self-checkout in the store.
The integration guide describes the API contract, and the API specifications on the NewStore developer portal are the contract of record. NewStore keeps the AI skills in sync with those specifications. Where they disagree, follow the specification and report the difference to NewStore.
The rollout phases and their lead times are also the same. See Planning the rollout.
Selecting a path
Consider | Path 1: AI skills | Path 2: Documentation |
|---|---|---|
Who builds the app | An AI coding assistant, guided by the NewStore skills and by your answers to its questions. | A developer or SI, working from the articles and the API specifications. |
Who you need in-house | Someone who knows the store, the PSP, the receipts, and the hardware, and who can answer questions in plain language. You still need a developer or SI to deploy and operate the app. | A developer or SI with experience in HTTP APIs, OAuth 2.0, a web frontend stack, and a small backend. |
How decisions are recorded | In a project profile that the intake skill writes and you review. | In the way your team documents projects. |
Best suited to | A first build or a pilot in one store, where you want a working app quickly and a clear list of what remains open. | A team that already builds against NewStore APIs, or that needs a specific stack, architecture, or integration into an existing app. |
You can also combine the paths. Start with Path 1 for the build, and use the articles from Path 2 to review and extend the result.
Path 1: Building with AI skills
What NewStore provides
NewStore provides the self-checkout plugin for Claude Code, which contains three skills:
Skill | What it does |
|---|---|
Intake ( | Interviews you about your project in business language, covering access, store, payment, promotions and coupon codes, receipts, deployment, design, and fallbacks. Writes the answers to a project profile, The intake skill also asks what type of app runs on the device for self-checkout, and if it is an app or browser based application. |
Guidance ( | Builds the app against the five self-checkout APIs, following the same contract as the integration guide. Starts the stub servers, writes end-to-end tests, applies promotions and coupon codes through the Promotions API before quoting tax, stores amounts as whole minor units, such as cents, takes totals only from the Tax Quotation API, and uses one idempotency key per placement attempt. Includes a migration reference for updating an app built against an earlier version of the contract. |
Retail design ( | Keeps the user interface in your brand. Uses your design system, components, or brand guidelines first and falls back to neutral styling only for the gaps. |
The plugin also contains the stub servers described in Running a self-checkout integration locally, so the assistant can build and test without credentials.
The plugin targets Claude Code. The skills are Markdown files and small scripts, so you can also give them to another assistant, such as ChatGPT, as project files together with the articles in this section. Other assistants follow the files as instructions but do not install them as a plugin. The interview, build, and handover flow described in How the build runs is how the skills run in Claude Code.
Ask your NewStore point of contact for access to the plugin and for its current version. The plugin changelog lists what changed between versions. Build with the latest version, because the self-checkout APIs are in beta and the skills change with them.
What you need
An AI coding assistant that runs the skills, and a computer with Node.js to run the stub servers and the app locally.
A person who can answer the intake questions. The questions are about observable facts: your tenant name, the store address, the company that processes your card payments, the terminal that stands at the lane, whether the store runs promotions or accepts coupon codes, and whether your printer already prints receipts. "I don't know" is a valid answer. The skill records the gap and who owns it.
Your NewStore tenant, with the store, the catalog, the price book, and stock configured. See the store, product, and stock tutorials.
A PSP account, a payment terminal for the lane, and PSP test credentials. See Integrating payments for self-checkout.
A developer or SI to deploy the app on the kiosk, connect the real terminal, lock down the device, and run the staging and production checks. The assistant builds the app. It does not deploy or operate it.
How the build runs
Install the plugin in Claude Code:
claude plugin marketplace add https://gitlab.com/newstore/engineering/checkout/experiments/self-checkout-eval.git claude plugin install self-checkout@newstoreAsk the assistant to build a self-checkout app. Because no project profile exists yet, the intake skill starts the interview before it writes any code.
Answer the questions. When the interview is complete, the skill writes the profile and asks you to read the plain-language summary and veto anything that is wrong. Check the store address carefully, because the tax rates depend on it.
The guidance skill builds the app against the stub servers, using the decisions in the profile, and runs the end-to-end tests.
Review the handover. It lists what the skill built, how to try it, what the app deliberately does not do, and what to confirm with NewStore: the credentials ticket, the store ID, and the API client to create in Omnichannel Manager..
Switch the app to your staging tenant when the credentials arrive. Follow Going live in the tutorial for the staging run, the production pilot, and the store readiness checks.
Important
A build that has only run against the stub servers has not connected to the NewStore platform. The handover states this. Treat the app as a prototype until it has completed a transaction in staging and you have verified the order and the payment in Omnichannel Manager.
Where NewStore helps
Provides the plugin and its updates, and the documentation that the skills point to.
Provisions the per-store credentials and the kiosk role on your support ticket. See Authentication and setup for self-checkout.
Answers configuration questions about the tenant, the store, the catalog, the price book, and the tax settings through your usual support channel.
Acts as the incident contact for platform issues. Quote the request IDs that the kiosk shows in its
call staffstate. See Operating self-checkout in the store.
What you do yourself
Answer the interview and review the profile. The decisions are yours, including whether NewStore keeps a platform receipt for each sale and which fallback the shopper sees when something fails.
Buy and set up the hardware. See Hardware prerequisites for self-checkout.
Set up the PSP account, board the terminal with your PSP, and provide the PSP test and live credentials to the payment backend.
Host the app, lock down the kiosk, and manage the device.
Run the staging test, the production pilot, and the daily login and monitoring procedures.
Review the generated code before production, with your SI or a developer. You own the app that the shopper uses.
Path 2: Building from the documentation
What NewStore provides
The four implementation articles in this section, in the order to read them:
Article | What it gives you | When to use it |
|---|---|---|
The stub servers for the five APIs, the demo barcodes and coupons, the cross-origin options, and the environment variables that switch between the stubs and the platform. | First. Build and test the whole flow before the credentials arrive. | |
Where payment sits in the flow, the thin backend that holds the PSP key, the Adyen and NewStore Payments terminal integrations, how to record the payment on the order, and payment troubleshooting. | While you build the payment step and set up the terminal. | |
The complete API flow, from catalog lookup to receipt creation, with the money-handling rules and the error table. | Throughout. This is the reference for every request and response. | |
A worked example for one store, from the credentials ticket to the first live transaction, including the rollout plan, the login flow, receipt printing, and the store procedures. | As the end-to-end walkthrough and the go-live checklist. |
Before you start, read Hardware prerequisites for self-checkout, Authentication and setup for self-checkout, for the hardware, the login flow, and the decisions that shape the build.
NewStore also provides:
The API specifications on the NewStore developer portal for the Catalog API, the Promotions API, the Tax Quotation API, the Order Placement API, and the Receipt API. The specifications are the contract of record for every request and response.
The stub server package, on request from your NewStore point of contact.
What you need
A developer or SI who can build an app for the kiosk device, web, desktop or native, and a small backend, and who works with HTTP APIs, JSON, and the OAuth 2.0 Authorization Code grant with Proof Key for Code Exchange (PKCE).
The same tenant, PSP, and hardware prerequisites as on Path 1.
How the build runs
Follow the phases in Planning the rollout:
Raise the credentials ticket and order the hardware on the first day. Both have lead time.
Start the stub servers and implement the five API calls in order: catalog lookup, promotions calculation, tax quotation, order placement, and receipt creation. At this stage, replace the payment step with a fake transaction. Follow the integration guide for every request and response.
Build the thin payment backend against your PSP test environment, with a test terminal and test cards. Record the PSP reference and, for Adyen, the merchant account on the payment instrument.
Add the login flow with the per-store credentials when they arrive, switch the base URLs to your staging tenant, and run the complete flow. Verify the order and the payment in Omnichannel Manager.
Run one low-value transaction in production on the live terminal, refund it through your PSP, and complete the store readiness checks.
Where NewStore helps
NewStore helps in the same way as on Path 1: the credentials ticket and OAuth client, configuration questions, and platform incidents. NewStore also provides the stub server package and the documentation, and answers questions about the API contract where an article and the specification disagree. The build itself is yours or of your SI partner.
What you do yourself
Everything in the Path 1 list, and the build: the frontend, the cart logic, the payment backend, the tests, and the receipt printing path.
Responsibilities at a glance
Task | Who | Path |
|---|---|---|
Platform APIs, promotion calculation, tax calculation, order records, and receipt documents | NewStore | Both |
Per-store credentials and the kiosk role | NewStore Support, on your ticket | Both |
API client with redirect targets, allowed origins, and token lifetimes | You, in Omnichannel Manager | Both |
Documentation and API specifications | NewStore | Both |
Stub servers | NewStore. Included in the plugin on Path 1, provided as a package on Path 2. | Both |
AI skills and plugin, with updates | NewStore | Path 1 |
Tenant, store, catalog, price book, stock, and tax configuration | You, with NewStore Support for questions | Both |
Answering the intake interview and reviewing the profile | You | Path 1 |
Building the frontend, the cart logic, and the tests | The AI assistant on Path 1. Your developer or SI on Path 2. | Both |
Payment backend, PSP account, and terminal boarding | You or your SI, with your PSP | Both |
Hardware selection, purchase, and setup | You | Both |
Hosting, kiosk lockdown, and device management | You or your SI | Both |
Staging test, production pilot, and code review before go-live | You or your SI | Both |
Daily login, monitoring orders in Omnichannel Manager, and first-line support in the store | Your store staff | Both |
Platform incidents | NewStore Support | Both |
Related topics