Skip to main content

Branded Sign-in & Sign-up

Give an app its own public sign-in page, with the app's logo and name, at a URL of its own. People who sign up or sign in there become users of that app and nothing else: the app is their home app, and they never see the Strongly platform.

This is for apps you hand to customers or a team of their own: a client portal, a review tool, an internal app for a department. Open the app from the Apps page and use its Permissions tab.

Where it lives​

Branded sign-in is part of the app's Permissions tab, which holds everything about who can open the app (Permissions): choose Sign-in required in its Access section to turn sign-in on, and set the pages up in its Sign-in section. Sign-in and public exclude each other: a public app has no sign-in.

Turning it on​

  1. Open the app's details page, choose the Permissions tab and its Access section.
  2. Under How app users get in, choose Sign-in required and confirm. Branded sign-in is on with the app's saved settings (or, the first time, a URL name made from the app's name, open sign-up and instant access), and the Sign-in section opens.
  3. Choose the URL name. It is the path of the app's sign-in page under your platform address, for example https://<your-platform>/app/client-portal/. Lowercase letters, digits and hyphens only, and two apps cannot share a name. Every app's pages are under /app/, so no name collides with the platform's own pages.
  4. Save.

You can also prepare the Sign-in section's settings while the app is still Private and save them; choosing Sign-in required then turns sign-in on with them. Choosing Private turns branded sign-in off: its pages close and its settings are kept.

Turning on branded sign-in also turns on Home App for the app: a user who signs in through the branded page lands in the app and stays in it.

Pages​

Once saved, the Pages list shows every public address the app now has, each with a copy button and an open-in-new-tab button:

PageAddress
Sign inhttps://<your-platform>/app/<url-name>/
Sign uphttps://<your-platform>/app/<url-name>/signup
Forgot passwordhttps://<your-platform>/app/<url-name>/forgot-password
Sign outhttps://<your-platform>/app/<url-name>/sign-out

The sign-in page links to forgot password itself, and to sign up when sign-up is on; share the sign-in address. Sign-up is off until you turn it on (see Who may sign up): until then the sign-up address shows that sign-up is closed.

New accounts confirm their email with a 6-digit code, and a forgotten password is reset with one: the emails carry the app's name and logo, and the codes are entered on the app's own pages (.../app/<url-name>/verify-email and .../app/<url-name>/reset-password), never on the Strongly sign-in page. The app's own iPhone app can use the same sign-in: see Native App Sign-in. The emails come from the platform's address unless the app has its own mail settings: then they leave through your SMTP server, from your address.

Upload a small logo (PNG, JPG or SVG, under 200KB). It replaces the Strongly branding on every page above. Without one the pages show the app's name.

Colours and heading font​

The pages take the app's own look, set in the same Sign-in section (or with PATCH /api/v1/apps/:id/auth):

SettingWhat it does
Button and link colour (primaryColor)The buttons and the links on every page.
Button text colour (buttonTextColor)The text on the buttons (the platform's is white).
Background colour (backgroundColor)The pages' background (the platform's is white).
Heading font (headingFont)A Google Fonts family for the headings and the app's name, for example Cormorant Garamond; the pages load it from Google Fonts. The body text keeps the platform's font.

Each colour is #RRGGBB; leave one empty (or send null) to use the platform's own. The pages must stay readable: the button text on the button, and the links on the background, must meet WCAG AA contrast (4.5:1). A combination below that is refused when you save, naming the pair to change. A font Google Fonts does not serve is refused too.

Who may sign up​

SettingWhat it does
Allow public sign-upOff until you turn it on. Off: the sign-up page is closed, the sign-in page has no sign-up link, and an email address that is not already one of the app's users cannot create an account (signing in with it answers "Incorrect email or password"); a sign-up that was started but never confirmed its email cannot be finished either. People join only when an app admin invites them (or adds an existing app user with Add User in the Users section of the app's Permissions tab). On: anyone who reaches the sign-up page can create an account.
New accountsEvery new account first confirms its email address with the 6-digit code it is sent (the code works for 10 minutes; the page can send a new one). Instant: the account is usable as soon as the email is confirmed; the confirmation page signs the user in. Approval: after the email is confirmed, the account waits until an app admin activates it in the Users section of the app's Permissions tab (administrators are notified); signing in before that tells them the account is waiting for approval. Signing in before confirming the email tells them to enter their code and offers a new one. A user an administrator deactivated is told their account has been deactivated. The platform needs email configured to take sign-ups: without it, sign-up says so.
Allowed email domainsWhen set, sign-ups and invitations must use an email address at one of these domains (subdomains included). Leave empty to allow any address.

Together these give four ways for people to join:

ModeSettingsWho gets in
OpenSign-up on, InstantAnyone who signs up, as soon as their email is confirmed
ApprovalSign-up on, ApprovalAnyone who signs up, once an app admin approves them
Allowed domainsAllowed email domains set, with either of the aboveOnly people with an address at those domains, whether they sign up or are invited
Invitation onlySign-up offOnly people an app admin invites

Invitations​

An app admin invites someone by email from the Users section of the app's Permissions tab, by asking STAN, or with the API. Give their email address, optionally their name, and their role in the app: User (the default) or Admin.

The person gets an email with the app's name and logo and a link to the app's own invitation page (https://<your-platform>/app/<slug>/invitation/...). There they choose a password and are signed straight into the app. Their account is active at once, with their email already confirmed, this app as their Home App and the role you chose.

  • Invitations work with sign-up off; they need the app's branded sign-in pages on.
  • Allowed email domains apply: an address outside them cannot be invited.
  • An address that already has an account cannot be invited; add an existing app user with Add User instead. An address with a pending invitation cannot be invited again: resend that invitation.
  • An invitation lasts 7 days. Resend sends a new link with a fresh 7 days, and the old link stops working. Revoke cancels a pending invitation, and its link stops working.
  • An invited user takes a seat like any other app user.

The invitations list shows each one's email, role, status (pending, accepted, revoked or expired), who sent it and when it expires.

With the API, your app can invite someone for one of its own pages: returnPath (a path inside the app, such as /invitations/123?token=abc) is where they land once they have chosen a password, and invitedByName is who the email says invited them. See POST /api/v1/apps/:id/users/invitations.

Someone who opens a link to a page inside the app while signed out is sent to the app's sign-in page. After they sign in (or sign up and confirm their email, or reset their password) they land on the page the link named, not on the app's start page. Only a page of the same app is ever opened this way.

App admins​

An app admin is a user whose role in the app is Admin. The app's owner manages the app's users as an app admin does; their role in the app stays Owner (appRole: "owner"). Make someone an app admin with the role selector in the Users section of the app's Permissions tab, or invite them as an admin.

The owner, app admins and platform administrators (on Strongly Cloud, also the admins of the app's organization) may invite people, resend and revoke invitations, approve waiting accounts, change roles, add existing users and send password resets.

Your app sees the role as appRole in the signed-in user's token: its owner is appRole: "owner" and an app admin is appRole: "admin". Open your app's own admin pages to appRole "owner" or "admin" rather than to a list of email addresses in its settings (Reading the user).

Someone who signs up:

  • gets an account with the app user role: they can use this app and nothing else on the platform (they hold no API keys);
  • gets their own organization and belongs to no other (on Strongly Cloud, they join the app's organization as a member). Either way the app's admins see and manage them in the Users section of the app's Permissions tab;
  • has this app as their home app: signing in takes them straight into it, full screen, with no platform navigation around it;
  • appears in the Users section of the app's Permissions tab.

Users​

Everyone who signs up appears in the app's one users table, the Users section of its Permissions tab, beside the Strongly users it is shared with. There you invite people, activate a waiting account, deactivate one (it is signed out), change a user's role, email a password reset code, give free access on a paid app, and remove a user from the app: see Permissions: Users.

Signing out​

A home app fills the whole screen with no Strongly controls, so the app provides its own sign-out. There are two ways; both end the user's session and show the app's sign-in page.

A link in the app. The app proxy answers _strongly/sign-out under the app's own address. From inside the app, link to it relative to the app's root with target="_top", so the navigation replaces the whole page rather than the frame the app runs in:

<a href="_strongly/sign-out" target="_top">Sign out</a>

Without an apps domain the app is served under a path prefix and the address is <STRONGLY_URL>/_strongly/sign-out, for example /api/proxy/<app-id>/_strongly/sign-out (see User Identity Headers). With an apps domain the app is at the root of its own host and it is /_strongly/sign-out: it signs the browser out of the app and of Strongly.

From script. A fetch of the same address ends the session and answers JSON with where to send the browser next:

const res = await fetch('_strongly/sign-out', { method: 'POST' });
const { redirect } = await res.json(); // "/app/<url-name>/" (or "/login" when the app has no branded sign-in)
window.top.location.href = redirect;

The sign-out page. https://<your-platform>/app/<url-name>/sign-out (in the Pages list) does the same from a plain link, so it also works from an email or a bookmark.

Either way the user lands on the app's sign-in page. For an app without branded sign-in, the same _strongly/sign-out address signs the user out and shows the platform sign-in page.

Charging for access​

An app with branded sign-in can charge its users with your own Stripe account: single-user plans, team plans with seats, or both. The setup, what users see and how subscriptions are managed are on their own page: Charging for Access.