Appmint — complete feature walkthrough map

Every API area with a direct link to its specification — 161 sections, grouped, not one list.

The browsable reference, the machine-readable surfaces behind it, and the path an agent follows to find one endpoint out of 3,036.

Long-lived credentials for server-to-server access, and how they resolve to a user.

Sign-up, sign-in, password reset and social login for the end users of a tenant.

Google, Facebook, GitHub and Microsoft — redirect flows and native token exchange.

Which credential to use for which kind of client.

2FA setup and verification, device fingerprinting, trust and blocking, and login history.

Operator sign-in, invitations, password management and session endpoints.

Headers, response envelopes, paging, error shapes, limits — the rules that hold across every endpoint.

Importing many records, streaming exports, and moving data between collections.

Defining your own datatypes, how schemas drive both validation and UI, and repairing a collection.

Upload, thumbnails, signed URLs, privacy, and the org-scoped storage layout.

State transitions, versioning, restore from history and trash, and per-record permissions.

The four shapes a page record can take, how the renderer chooses between them, where page CSS and JavaScript live, and how to write a page without losing what was there.

One generic controller that serves create, read, update and delete for all 261 datatypes.

The site record — the home page, hosts and domains, logo and favicon, tracking and SEO — and the two fields whose shape is not what you would expect.

Connect an AI client to AppEngine over the Model Context Protocol — discover services, read their signatures, and call them.

Chat, agents, MCP tools, image and video generation, AI employees, voice, and API discovery through MCP.

Asking for access to a screen or a guarded operation, and deciding it from a tray, through the org's workflows.

Event-driven automations, AI-generated flows, and the generic task workflow engine with SLAs.

Bank linking for the books — connect accounts through Plaid, read balances and transactions, and reconcile them. Read-only; no money moves.

The endpoints behind BusinessMade — people, time, pay, benefits, bills and the ledger.

The signed-in customer's own account — profile, orders, forms, reservations, tickets, messages, addresses, wishlists, files, benefits, shared accounts and payment links.

Pages, posts, stories, follows, connections, direct and group messaging, meetings, blocking and reporting, plus social-listening topics.

Posts taken page by page — courses, applications, trainings, documentation — with outline, access, progress, answers, marking and review.

The design library and the editor's save path — searched and paged listings, new designs, saves, copies, previews and uploaded images.

Leads, pipelines, campaigns, ads, tickets, reservations, signed documents and the AI assistant.

The server side of Device Hub — hub keys and live state, remote peripheral config, device calls, and the event stream back to screens.

Events, ticket types, sessions, QR validation, badges, credentials, check-in and event media.

Internal balances, payout workflow, and gateway-agnostic payment operations.

Who is dealing with a record — take it, finish it, give it back — on any datatype, for people and AI employees alike.

Delivery jobs, pricing quotes, zones, drivers, live tracking, proof of delivery, customer orders with payment, and driver earnings and payouts.

Phone numbers, inbound call routing, SMS keywords and auto-replies, email broadcast and live chat.

Usage metering and token balances, monitoring and analytics dashboards, vendor connections, upstream integrations and cluster management.

Render a record as a full-page PDF or as thermal receipt lines, from built-in templates.

The two-layer model behind configurable products — the reusable definition, the per-product subset, every attribute type, file uploads, the required rule and how option prices reach the order.

Selling the same catalog on Amazon, eBay, Etsy and elsewhere — mappings, inventory sync, order aggregation and pricing.

Everyone who works in the org — people and AI employees — with what a colleague needs to reach them.

Catalog, cart, checkout, payments, orders, POS, inventory, pricing, discounts, returns, rentals and tax.

Space custody — listings, carts and holds, bookings with per-item sessions, movements, delegated pickups, fees, settlement and host payouts.

Team workspaces and conversations — members, a journal of messages, files, tasks, meetings and agendas, with a personal Home, Inbox, My Tasks and My Calendar.

What AppEngine exposes, how it is organized, and how to find the endpoint you need.

Where your team works chats — queue, presence, transfers, AI handover, calls, screen sharing and broadcast.

An embeddable chat widget with live agents, queueing, presence and AI answers — dropped onto any site with two script tags.

The queue behind the Check-in screen — the workflow it runs on, what each host action writes, the notifications it sends, and the other pipelines the platform creates for you.

Bluetooth printers, barcode scanners, NFC readers and card readers — pairing them to a phone or tablet.

Business locations, the service points inside them, their statuses, and which part of the platform is allowed to change each one.

The product fields the point of sale reads, day-parts and the 86 list, the per-location overlay, and how selling draws stock.

Which emails and texts the platform sends for the things this app does, where the templates and copy-to settings live, and what push actually exists on mobile.

Reservation definitions, services, hours and slots — what to configure so the booking wizard offers the right times, and what the app can and cannot change.

Who can sign in, how quick sign-in and NFC access cards are controlled, and what happens when a device is blocked or an account is removed.

Everything the app stores on the device, what survives signing out, and which settings are per device versus per organization.

Which backend a build talks to, how the development and production environments are chosen, and what the app stores on the device.

The server-side settings the app reads — quick sign-in, locations, payment gateways, receipt templates, workflows, rate limits — and one security note about the storefront routes.

Gateways, Stripe Terminal readers and Tap to Pay, the tender model at checkout, refunds and receipts — and what is not there.

Thermal printers over Bluetooth, USB and network, the server-rendered receipt and check payloads, cash drawers, and shared printers through the device hub.

How the app boots, how state and networking are layered, and which services talk to which part of the platform.

The Dart models under lib/models, the server datatypes they map to, and the fields and enums that matter.

Every route Appmint Mobile calls, grouped by module, with the auth each one actually enforces.

What the September 2026 test pass fixed, what is still open, and the parts of the codebase that promise more than they do.

Every folder under lib, what each screen class is for, and which root documents are still accurate.

Versions, identifiers, permissions and the exact App Store and Play upload flow that has worked.

Debug builds against a local backend, the web build that lets you drive the app from Chrome, and the rules that stop you chasing ghosts.

Install the app, sign in, and set up a device for the way it will be used.

Your business command center — POS, CRM, payments, scanning, events and communications in one app.

A full shift end to end — open the floor, seat from the queue, take and fire orders, settle, release tables, and handle no-shows.

Quick sign-in with a passcode or card, saved sessions, switching organizations, and what the location picker scopes.

Scanning, searching, the scanner modes, refresh habits and what needs a connection — the small things that make a busy shift faster.

Every symptom worth knowing, what causes it, and the order worth checking — sign-in, sync, chat, calls, hardware, payments and the door.

Leads, contacts, customer journeys, support tickets and tasks — the full CRM, worked from a phone.

Run the door — scan tickets in and out, look people up when their phone fails, register walk-ins, issue and comp tickets, and watch occupancy live.

Every job you can do in Appmint Mobile — using it, administering it, and fixing it — in the words you would use, with the page that walks you through it.

The unified inbox, email and SMS, the live chat console, presence, and the in-app softphone — how to work them, and what to check when a message or call does not arrive.

Signing in and out, the More tab, quick-login passcodes, access cards, the home layout — and what each setting actually does today.

The four operations screens — Tabs, Floor, Reservations and Check-in — and how a party moves between them.

Fired items become tasks in a workflow — this screen is where the kitchen, the bar or any prep station works them.

Products, carts, modifiers, firing to the kitchen, settling with any tender, receipts and refunds — from a phone or tablet.

Charge an amount that is not on a menu — a deposit, a service fee, a phone order — through the same checkout as a tab.

Why a service must be accepted before it runs, and where the current terms are served from.

Balance, provider cost, platform markup, subscriptions and what happens when funds run out.

Every subscription plan, what it costs monthly and annually, and the limits attached to each.

Every metered service, its unit, its markup, and the underlying provider rates.

Getting hundreds of products in from JSON — the record shape, images, the fields that are not where you expect, and making the load re-runnable.

An on-canvas text editor with fonts, rotation, arc-curving and live pricing — 113 KB of JavaScript in one page record, read end to end.

The two-layer attribute model behind custom products — a shared definition, a per-product subset, file uploads, the required rule, and how option prices reach the server.

How your site plays posts — blog posts, galleries, courses, applications and trainings — page by page, with progress, conditions, review and preview.

Rendering live records into a page — declaratively with six attributes, or in code when the markup stops being enough.

Keyword search and reactive filters, plus the stats API behind views, likes, favourites, shares and ratings — including the three rules that make it behave.

The production pipeline — author a site as plain HTML you can open from disk, then deploy it to page records with one command, safely and repeatably.

The advanced track — what you can actually build on Appmint, the three places your code can live, and how to choose between them.

The two stores available to a page application — the runtime's reactive state and your own object — what each is for, and how to redraw without a framework.

Every trap in this section listed by what you actually see, because at 2am you search for the symptom, not the cause.

You can read any datatype from a page. You cannot write one the same way — and the three routes out of that, with the cost of each.

The four signals that you have outgrown a page application, and what the crossing actually costs — from a marketplace built headless over AppEngine.

The page record's style.javascript field, the readiness gate every page app needs, and why the script tag in your HTML does nothing.

Application credentials, the tenant header, and how a signed-in visitor's identity is carried to AppEngine without exposing anything to the browser.

The endpoints a client application actually calls — auth, catalog, cart, checkout, orders, and the customer-scoped client/* surface.

The error envelope, the codes you must handle, and what each one actually means.

Clone the example repository, point it at your organization, and have a working storefront running in a few minutes.

Two kinds of people, three endings to a sign-in, verification codes, shared devices and remembered accounts.

The package that talks to AppEngine from Flutter — app authentication, staff and customer sign-in, and reads and writes over any datatype.

Caching reads, queueing writes, and being honest about what cannot work offline.

Reads and writes over any datatype, the escape hatch for everything else, and what the errors mean.

Build a working Flutter app on AppEngine from an empty folder — sign-in, verification codes, a session and a real read — in about twenty minutes.

window.appmint — the JavaScript API that HTML pages and no-code markup use to reach the platform, and how it bridges to the host application.

Build your own site, app or storefront on the AppEngine API — the call path, the clients, and runnable examples.

Your first working call, then sign in a customer, list products, price a cart and place an order — with runnable requests and real responses.

The WebSocket surface — connecting, authenticating, the event vocabulary, and why this is the one case that talks to AppEngine directly.

The pattern that puts your own server between the browser and AppEngine, with the working implementation from base-app.

A complete walkthrough — install the client, stand up a proxy, render a catalog, and price a cart the server can vouch for.

Build a working storefront on AppEngine from an empty folder — catalog, cart, promo codes and a total you can charge, explained decision by decision.

The Devices and Hubs screens in BusinessMade — diagnosing, editing, rotating keys and moving locations.

Peripherals are discovered by the hub — you connect the ones you want. Plus what each device type needs.

Connects in-venue USB peripherals — printers, scanners, cash drawers, NFC readers — to the platform.

Create the hub, install the agent on a venue box, and pair it with your organization.

Working through a hub or device failure in the right order.

Pages, announcements, stories, moderation, connections and what staff can do from the admin side.

Running the event from Appmint Mobile — the event shell, scanning and check-in, the accreditation desk, badges, live numbers, and what is not wired up yet.

The event record, sessions, ticket types and participants — every field the attendee app and the door depend on.

Every email, SMS and in-app notification the event and community modules send, what triggers it, and what push actually exists.

Running the door — check-in, accreditation, badges, occupancy and the live dashboard.

How a purchase becomes tickets, how QR codes rotate, and what transfer, comp, fulfil, cancel and refund each do to the numbers.

Which backend, organization and keys the app is built against, and the headers every request carries.

Where event photos, cover images and attendees' own uploads live, how signed URLs work, and the limits worth knowing.

The organization and site the app belongs to, what is public without a token, rate limiting and the server variables behind events and community.

How a ticket purchase is charged — Stripe intents, the payment sheet, confirm-order, free events, guest checkout and what the web build does instead.

How the attendee app boots, its two shells, the two-token HTTP client, and the services behind tickets, community and chat.

The event, ticket, session and participant records, the community records behind the feed and chat, and the rules the server enforces on each.

The client/events and client/community surfaces the attendee app uses, the auth calls around them, and the chat socket events.

What the September 2026 test passes fixed in the app and on the server, what is still open, and the dead code to ignore.

Every folder and screen in the EventOxygen codebase, plus which root documents describe the current app and which are history.

Identifiers, the EventOS versus EventOxygen naming, and the App Store and Play upload flow.

Debug builds, the phone-sized web build that lets you drive the app from Chrome, the dev login, and the seed scripts.

Install the app, sign in, find your event, and get your ticket in front of you.

Your all-in-one event companion — tickets, badge, schedule and networking, with check-in and live dashboards for organizers.

The checklist before you travel, what needs a connection, switching events, multiple tickets, guests and sharing a booking.

Using the directory filters, follow versus connect, meeting requests that confirm, bookmarks, shares and hashtags well.

Sign-in, missing tickets, empty schedules and directories, feed and comment errors, chat, payments and slow images — in the order worth checking.

The two shapes of the app, what the event home shows, the calendar-based schedule, the media gallery and the drawer.

The Explore feed — posting, polls, reactions, comments, sharing, reposts, bookmarks, stories and announcements.

Message threads, the chat screen, sending photos, starting a new conversation, and the Notifications tab.

Your profile, editing it, your QR card, your media library, legal and support links, signing out and deleting your account.

Connecting with people, your QR profile card, handling requests, messaging and how scoping works.

The attendee directory, what Connect, Follow and Message each do, profiles, and booking a meeting with someone.

Buying, finding, showing and passing on a ticket — and what to do when something goes wrong.

Build the authentication example from scratch — connect to an organization, sign staff and customers in, answer verification codes, and watch every call the client makes.

Build the chat example from scratch — a customer signs in, opens a support conversation over the realtime gateway, waits in the queue, and talks to the agent who picks it up, with every socket event shown beside the thread.

Build the community example from scratch — a feed of posts written by customers, a comment thread, reactions that wait for the server, hashtags, and reporting.

Build the CRM example from scratch — capture a lead without duplicating one, work it with actions the server records, look people up and read their journey, and text or call them through the organization's number.

Build the events example from scratch — create an event, add a ticket type, issue a ticket, and work the door with check-in, re-scan and check-out against a live server.

Build the payments example from scratch — open a tab, put items on it, and settle it one tender at a time: cash with change, a card with a reference, a split, a refund, and a receipt printed or sent — with every rule the server enforces shown in its own words.

A working web storefront — catalog, product pages and a cart — with the application credentials kept off the browser by a thin server proxy.

Working apps built on AppEngine — a storefront, a sign-in, a till, a door scanner — each one a tutorial you can follow.

Build a Remix store against AppEngine from an empty folder — catalog, product pages, a server-priced cart and a full reservation booking flow.

Organizations, datatypes, BaseModel, and the difference between a user and a customer.

The vocabulary that shows up in Appmint source and these docs.

Sign in, read the token apart, and fetch records — with the exact payloads AppEngine returns.

One backend for commerce, CRM, operations and payments — and the products that run on it.

Every provider currently available, grouped by type, with what each is used for.

Three provisioning models, automatic fallback to platform credentials, and bringing your own provider.

Connected services, OAuth, webhooks and marketplace channels.

How capture works on LinkedIn and Google Maps — and why the two behave differently.

Get the extension, load it into Chrome, and connect it to your organization.

A browser extension that captures B2B leads from LinkedIn and Google Maps straight into your CRM.

Auto-sync, default pipeline and stage, lead source, AI provider and notifications.

Connection, capture and sync problems, in the order worth checking.

Hire an AI employee, give it access, connect it to the system that runs it, confirm it is really running, give it work and answer what it asks — and what that system needs to know.

What runs where, what each dependency is for, and how a request travels through AppEngine.

BaseModel, the fields you get for free on every record, and how collections and subschemas work.

All 261 built-in datatypes, grouped by the part of the platform that owns them.

Users, customers, API keys and service accounts — and the exact order authorization is decided in.

How an orgid becomes a database, how domains resolve to tenants, and where the isolation boundary actually is.

Profile, billing, API keys, usage and logs.

AI assistants, phone menus, automations, workflow tasks and schedules.

Inbox, analytics, dashboards, activity feed, domains, sites, services and the setup wizard.

Every method callable from data-action, data-source or the JavaScript API.

The interactive web components a published page can use — tabs, dialogs, drawers, sliders, grids and navigation.

What runs after an action, and how bound values are rendered.

Build pages, forms, presentations and graphics — bound to live data — then publish.

The style slots on a page record, what executes and what does not, and the constraints that apply to code running inside a rendered page.

The data-* attributes that make a published page live — binding, lists, actions, visibility and formatting.

Pages, feed, stories, connections, messages, groups, meetings, announcements, badges, hashtags and moderation.

Locations, users, groups, roles and permissions, password policy, integrations, escalation and translation.

Leads, pipelines, forms, campaigns, tickets, reservations, AI employees and a single view of every customer interaction.

Write single posts and multi-page documents — articles, courses, applications, trainings — set who can open them and in what order, preview, publish, and follow the people taking them.

Content Studio (posts, multi-page documents and courses), categories, navigation, tags, comments, documents, site notices and message templates.

Collections, sub-schemas, import and export, and the data explorer.

Events, sessions, ticket types, bookings, badge templates, speakers, exhibitors, check-ins and leads.

Wallets, payouts, wallet transactions and payments.

Delivery zones, delivery agents and delivery jobs.

The console you sign in to — what each area does, and how the whole surface fits together.

What an automation can do to a live call — speak, collect, transfer, record, pay and hand off to AI.

Get a number, decide how calls are answered, and route them to the right people.

Catalog, cart, checkout, payments, orders, inventory, pricing, discounts, returns, rentals and point of sale.

Visual AI app builder — describe what you want, then refine it visually against your real data.

An AI coding agent that builds against your own data, with multi-provider models, streaming and usage controls.

Sign in as an operator, read a record, write a record — and the one header that makes reads fail in a way the error message does not explain.

Take a folder of hand-written HTML to a live multi-page site — how pages are stored, a deploy script that is safe to re-run, the rewrites the platform expects, and how to verify a deploy without trusting status codes.

Define a CRM form, open it to anonymous visitors, post to it from a page, and read the submissions back — including the permission that has to be set twice.

Configure a supported integration, test a provider operation, distinguish a custom API from a catalog provider, and verify email delivery.

Choose a portal layout, enable sections, save and verify the customer experience with separate identities.

Name your site, choose a design or AI brief, create a page, customize it, preview it and prepare publishing.

A practical map from mobile sign-in to CRM, chat, calls, events, scanning, administration and hardware.

Every tutorial and example app, the three ways to reach the platform, and the setup every tutorial assumes.

Where page JavaScript actually goes — the page record's style field — why inline script tags never execute, and the attribute bootstrap for when you only control the HTML.

Upload an image, generate favicon.ico and favicon.png from it, and wire both into the site record — the smallest complete task that touches files, a generator and a write.

Enable calling, acquire or connect a number, assign a user/group, configure routing and verify voice and SMS independently.

Define a bookable service, generate real availability, and create a reservation — from the server API and from a page, with a clear line between the endpoints that are public and the one that is not.

Create a chat configuration, embed it, make an agent available and verify a visitor-to-agent conversation.

From signup to your first draft page: create your workspace, finish essential setup, find the builder and verify your first small win.

Meet Appmint Mobile through the jobs people actually do: customers, conversations, calls and events.