To publish an AI-built app in Insulin Apps is to give one of its saved versions a live URL, and the decision that comes with it is who can open that URL. Console-only means people signed in to the Fours console who have access to the app; the app’s card labels it Team only. Public means anyone with the URL, with no sign-in at all. The rule for choosing fits in one sentence: an app goes Public only when every route its server code exposes is one you would let a stranger call without signing in. Otherwise it stays Console-only.
Check older apps before anyone publishes them. A new app starts Console-only, but in the words of Fours’ documentation, “Apps created before this setting existed are Public until someone changes them.” Anyone with Editor or higher on an app can publish it, while changing who may open it takes the app’s Owner or an Admin on it. An Editor can therefore put an older app on the open internet with its first publish, and has no way to switch it back. Open Settings → Access → Published access on every app made before the setting existed, and settle it before that first publish.
What the setting leaves alone matters as much as what it changes. The documentation puts it in one line: “The access setting decides who can open the app, not what its code can reach.”
Who can open a published app: Console-only or Public?
Console-only keeps the app behind your organization’s console sign-in; Public puts it on the open internet. The Published access setting is the one switch between them. The rows where the two options agree matter as much as the rows where they differ.
| Console-only | Public | |
|---|---|---|
| Who opens it | People signed in to the Fours console who have access to the app | Anyone with the published URL |
| Sign-in | Each person’s own console sign-in | None |
| Where it answers | The runner window, or the console’s Insulin Apps page, in a browser with credentialless iframes such as Chrome or Edge; opening its address takes you into the console | Its default domain, <name>.insulin.host, which an app admin can rename; a live Public app’s old address then redirects for 30 days |
| What its code can reach | The same in both: the app’s own Fours API client with the Editor role, the secrets delivered at publish, and more the docs describe | The same |
| Who can switch it | The app’s Owner or an Admin on it; a personal app’s creator is its Owner | The same, after confirming Allow public access? |
| When a change applies | At the next publish; Live access shows what the live app uses now | The same |
| When someone loses access | Re-checked every few minutes; the app stops within about five | Nothing to end, because nobody signed in |
| Default | Every new app | Apps created before the setting existed |
| A personal app | You alone | Anyone with the URL |
Console-only borrows the console’s sign-in, so removing someone’s access takes effect. “Your access is re-checked every few minutes, so if it is removed while the app is open, the app stops within about five minutes.” The cost is the browser: the runner window needs credentialless iframes, and in a browser without them it asks people to switch to Chrome or Edge.
Public has no sign-in, so access can’t be taken from one person. Removing someone’s share changes what they can do in the builder, not whether they can load the URL; ending public access means switching the app back to Console-only and publishing, as below: “Sharing still decides who can edit the app.” Who may open, use and edit an app inside your organization is a separate decision, covered in how to share an internal app with role-based access.
A random address is not a password. A Public app’s default domain starts as a random five-letter name under insulin.host. In May 2026, Security Boulevard reported research by RedAccess that found “about 380,000 publicly accessible applications and other assets” from vibe-coding tools, “about 5,000 of them” holding sensitive corporate information, and noted that “many of the applications were indexed by Google and other search engines.” Plan as if the URL will be found.
A setting change waits for a publish, in both directions. Switching a Public app back to Console-only doesn’t take it off the internet until a saved version is published, and until then Live access still reads Public. To close a Public app, change the setting, publish a saved version, and confirm that Live access reads Console-only.
What can a published app’s code reach?
The same things under either setting. How a published app reaches your Fours data is explicit that “Console-only and Public apps both get” the app’s Fours API client. Two of the things its code reaches decide most reviews:
- Your Fours data, as an Editor. Every app has an OAuth client of its own, and “the Fours API treats every call the client makes as coming from an Editor, for organization and personal apps alike.” The app’s server code can do what an Editor can do through the Fours API, which means reading and writing. A published app holds the client’s credentials, delivered when it is published.
- Outside services, through Secrets. A key stored under the app’s Secrets reaches the live app at publish, and “anyone who can edit and publish this app can read these values from its environment.” Who can read those keys while the app is being built is its own question, answered in who can read the API keys in an AI-built app.
Those two start the inventory; they don’t finish it. The docs’ What a Published App Can Reach section describes more, and a review should work from that page and the app’s code rather than from a list in a blog post. Two more belong in it whatever the app does:
- Model calls are your organization’s spend. When an app calls a model at runtime, “those tokens are metered and priced the same way a chat turn’s are,” per the metering page. A Public app asks nobody to sign in, so any visitor who reaches a route that calls a model starts spend that comes off your organization’s credit balance.
- The app’s own database is a third store. It is separate from your Fours data, and whatever a route returns from it, a Public visitor receives. What happens to an AI-built app’s data when it changes covers that database.
Why isn’t a personal app private once it is published?
Because “personal” limits sharing, not the published URL. Choosing Only I will use it when you create an app makes a Personal app, “which can never be shared.” Its creator is still its Owner, though, and an Owner can both publish an app and switch it to Public.
An organization EDITOR, who can create personal apps but not organization apps, can therefore build an app no teammate sees, publish it and make it Public. Its server code still calls the Fours API as an Editor. Nothing in the documented publishing rules asks an organization admin to approve either step, so the people who can put an app on the open internet include every member allowed to create one.
Should your AI-built app be Public? Four questions for its server code
Keep it Console-only if any route answers yes to any of these. None of the publish steps reviews what a route exposes, so the review is yours. Open the app’s server code in the builder and go route by route:
- Does it call the Fours API? That call runs as an Editor, for whoever reached the route.
- Does it use a secret? Whatever the key can do at the outside service, the route can do for its caller.
- Does it call a model? Its tokens are metered like a chat turn’s and come off your organization’s credit balance, and on a Public app the caller never signed in.
- Does it return or write rows in the app’s own database? A Public visitor sees what it returns and adds what it accepts.
These four are where a review starts, not where it ends. Anything else the server code can call counts the same way, and if you can’t answer for every route, the app isn’t ready to be Public.
Console-only fits any app whose routes should require a sign-in. A deal desk approvals app, a renewal follow-up tracker or a dashboard over your marketplace data each reads or writes something a stranger should not see, and the people who need it already sign in to the console.
Public fits an app with nothing to protect at any route. Take a sample ROI calculator Acme offers prospects: the page does the arithmetic, and the server calls nothing, stores nothing and returns nothing it holds. Even then the published app holds its Editor-role client credentials, and any secrets it was given. Before you set it Public, read every route and every dependency it pulls in, and confirm that none of them hands those credentials, or anything they can reach, to a caller.
What does publishing do, and how do you roll back?
Publishing builds a saved version and records it as live once the app’s URL answers with it; rolling back is publishing an earlier saved version. Unsaved changes never publish, and if a step fails before Go live, the panel confirms “Production is unchanged — still vM.” Each step is set out in what happens when you publish.
A rollback has one caveat. A publish’s Update database step means “New migrations are applied to the published app’s database,” and the documentation describes no step that reverses one. So don’t count on a rollback to undo a migration: before you publish an earlier version, check that its code still works with the database as it is now.
To see the builder, its roles and its encrypted secrets before you publish anything, start with Insulin Apps, the AI app builder for business apps.
Sources
Primary sources for the platform rules cited above. Last verified November 6, 2026. Providers change their products, prices and terms without notice — check the source before relying on a detail.
- Insulin Apps — Fours Doc — Publishing: a saved version put in production with its own live URL, publishing open to Editor or higher on the app, only saved versions published, a failed step before Go live leaving production unchanged, Update database applying new migrations to the published app's database, and publishing an earlier saved version as the way to roll back. Who can open a published app: Settings → Access → Published access, Console-only (signed-in console members with access to the app; where a new app starts) or Public (anyone with the published URL; sharing still deciding who can edit), apps created before the setting existed Public until someone changes them, only the Owner or an Admin on the app changing it, Allow public access? on the switch to Public, the change taking effect at the next publish and Live access showing what is live. Where a published app answers and The app's domain: a Public app's default insulin.host domain with a random five-letter name an app admin can rename, the old address of a live Public app redirecting for 30 days, a Console-only app opening through the console under your own sign-in. Running a Saved App: the runner window's credentialless iframe, Chrome or Edge, access re-checked every few minutes and the app stopping within about five. What a Published App Can Reach and How a published app reaches your Fours data: the app's own OAuth client calling the Fours API as an Editor for organization and personal apps alike, Console-only and Public apps both getting it. Secrets reach the app when you publish. Ownership and Sharing: a Personal app never shareable, an organization EDITOR creating personal apps only. Finding and managing your apps: the Team only and Public card labels
- Insulin Metering — Fours Doc — AI that an app runs is billed like any other AI: an app's runtime model tokens metered and priced the same way a chat turn's are, and taken off your credit balance
Keep reading
Stay Updated
New posts, product updates and marketplace strategy are shared on LinkedIn as they publish.
Follow Fours on LinkedIn