Skip to content
← All guides

App Store

Rejected under Guideline 2.1 because App Review could not sign in: how to set up a demo account that works

By Jan Lipmann, appienceChecked against sources on 9 min read

If your app has a login, Apple expects a working demo account in App Review Information and a backend that is switched on while the review runs. A rejection for "could not sign in" is about the account and the backend, not the app's design, and each possible cause is something you can check yourself. Guideline text below is quoted from the version last updated on 2026-10-16.

App StoreSupabaseLovable

What you are seeing

The rejection arrives in App Store Connect, on the App Review page of your app. It cites Guideline 2.1 (App Completeness, in the Performance section) and says that the reviewer could not sign in, that the demo account did not work, or that no demo account was provided. Read the full message in App Store Connect rather than the notification email: the exact wording varies, and it may say which step failed.

Close relatives of the same problem, all under 2.1:

  • The reviewer signed in, but the app showed a spinner, an empty screen or a network error, because the backend was paused, down or pointed at a development project.
  • The login asked for a code sent by email or SMS, and the reviewer had no way to receive it.
  • The reviewer could sign in but could not reach part of the app, for example an admin role, a paid tier or a subscription purchase flow.

Apple's App Review page says that on average over 40% of unresolved issues are related to guideline 2.1, and lists incomplete information, including a missing demo account, among the most common issues.

How to check it yourself

Start with what Apple actually asks for. From Guideline 2.1(a):

“Make sure your app has been tested on-device for bugs and stability before you submit it, and include demo account info (and turn on your back-end service!) if your app includes a login.”
- App Store Review Guidelines, 2.1 App Completeness

Then check the demo account and the backend the way a reviewer meets them: on a fresh install, with only what you wrote in App Store Connect. Everything below runs against your own project only.

1. Read what you gave App Review

In App Store Connect, open your app, select the version you submitted and scroll to App Review Information. Check that Sign-in required is ticked, that the username and password are filled in, and that Notes explain anything that is not obvious. Apple's reference for these fields says the demo account "must not expire", that details for additional accounts go in Notes, and that Notes hold up to 4000 bytes.

2. Sign in with exactly those credentials

  1. Copy the username and password from App Store Connect, not from your password manager - a typo or a trailing space in the field is enough to fail.
  2. Install the build you submitted (through TestFlight) on a real iPhone. Delete any earlier install first, so no saved session hides the problem.
  3. Sign in with the copied credentials. Then sign out and sign in again.
  4. Walk through every screen a reviewer needs: main features, settings, account deletion, any purchase flow.

If you want to rule out the app itself, you can test the same credentials directly against Supabase Auth from a terminal, using the public key that is already in your app (Supabase password sign-in):

curl -X POST "https://YOUR-PROJECT-REF.supabase.co/auth/v1/token?grant_type=password" \
  -H "apikey: YOUR_PUBLIC_KEY" \
  -H "Content-Type: application/json" \
  -d '{"email": "review@yourdomain.com", "password": "THE-PASSWORD-FROM-APP-STORE-CONNECT"}'
A response with an access_token means the account works. An error names the reason - for example invalid_credentials or email_not_confirmed (see Supabase Auth error codes). Use the project URL your release build points at, not a development project.

3. Check the account in the database

In the Supabase dashboard open SQL Editor and run (read-only):

select id, email, email_confirmed_at, last_sign_in_at, banned_until, created_at
from auth.users
where email = 'review@yourdomain.com';
No row: the account does not exist in this project. email_confirmed_at is null: the email was never confirmed. banned_until in the future: the account is banned.
  • email_confirmed_at empty: by default a user with an unverified email cannot sign in (Supabase users). The reviewer cannot open your confirmation email.
  • last_sign_in_at: note it before you run the sign-in test from step 2, because a successful sign-in (yours included) overwrites it. If it is empty or older than the review date, the reviewer never got through sign-in, which points to the credentials or to the backend.
  • No row at all, but the account works on your laptop: your development build and your release build talk to different projects.

Then check whether the demo account has a second factor that the reviewer cannot provide (Supabase MFA):

select f.factor_type, f.status, f.created_at
from auth.mfa_factors f
join auth.users u on u.id = f.user_id
where u.email = 'review@yourdomain.com';
A row with status = 'verified' means signing in needs a code from an authenticator app or phone that only you have.
Note: On Lovable's built-in backend (Lovable Cloud) you may not have a SQL Editor of your own. The account list is under More, then Users (Lovable: users and authentication), and the sign-in test from step 2 is the quickest check.

4. Check that the backend is awake

  • Supabase pauses Free plan projects that show low activity over a 7-day period, and sends a warning email about a week before it happens (Supabase project pausing). Open the Supabase dashboard: a paused project shows a Resume project button. Paid-plan projects are not paused for inactivity.
  • Check the Supabase URL your release build uses. Search the built web files (for example grep -rho "https://[a-z0-9]*\.supabase\.co" dist | sort -u) and compare it with the project you checked above.
  • If the app calls your own server or Edge Functions, make sure they are deployed to production and respond.
  • If you block sign-ins or traffic by country, IP range or device, remember the reviewer is not on your network.

Why it happens

A reviewer can only use what you put in App Review Information, on a device that has never seen your app. Anything that relies on your inbox, your phone, your saved session or your development setup fails for them, even though it works every time for you. In apps built with AI tools on Supabase or Lovable Cloud, the causes behind a failed demo login come down to a short list:

  • No demo account, or Sign-in required not ticked.
  • The account exists only in a development project, or was deleted - for example by testing your own account deletion flow on it before submitting.
  • The account was created by signing up in the app with Confirm email on, and the confirmation link was never clicked. Supabase's Confirm email setting means users must confirm their address before signing in for the first time.
  • The password changed after submission. Apple's complete review guidance warns that credentials that expire or change before the review starts may result in a rejection.
  • The login sends a one-time code or magic link (email OTP, SMS, MFA) and nobody gave the reviewer a way to get it.
  • The only sign-in option is Google or another third-party login, and the demo details for that service were missing or the provider asked for extra verification the reviewer could not complete.
  • The backend was off: a paused Free plan Supabase project, an expired trial on another service, or an API that only runs on your machine.
  • The account signs in, but has no data, no role or no subscription state, so the reviewer cannot see the features the app is about.

How to fix it

1. Create a dedicated, confirmed demo account

Use an account that exists only for App Review, on an address you control (for example review@yourdomain.com), with no real customer data. Do not hand over your own account or a customer's.

  • Lovable Cloud: go to More, then Users, click Add user and choose Create new user. Lovable's docs say users created this way are automatically confirmed (Lovable: email authentication).
  • Supabase: create the user with the Auth admin API and email_confirm: true (createUser). This needs your project's secret key, so run it once from your own computer, never from the app.
// create-review-user.ts - run once from your computer, never ship it in the app.
import { createClient } from "@supabase/supabase-js";

const url = process.env.SUPABASE_URL;
const secretKey = process.env.SUPABASE_SECRET_KEY; // sb_secret_... (or the legacy service_role key)
const password = process.env.REVIEW_PASSWORD;
if (!url || !secretKey || !password) {
  throw new Error("Set SUPABASE_URL, SUPABASE_SECRET_KEY and REVIEW_PASSWORD first.");
}

const supabase = createClient(url, secretKey, {
  auth: { autoRefreshToken: false, persistSession: false, detectSessionInUrl: false },
});

const { data, error } = await supabase.auth.admin.createUser({
  email: "review@yourdomain.com",
  password,
  email_confirm: true, // confirmed now, so no email is needed
});
if (error) throw error;
console.log("Created review user", data.user.id);
Based on the createUser reference and the server-side client setup in Supabase users. The secret key bypasses Row Level Security: keep it in your shell environment, not in the repository or the app.
Warning: Do not switch off Confirm email for the whole project just to get the reviewer in. Supabase warns that this lets anyone sign up with an address they do not own (Test auth flows). Confirm only the demo account.

2. Give the account something to show

  • Fill it with realistic sample data, so the main screens are not empty. 2.1 asks for a demo account or demo mode that lets the reviewer see the app's features, and an empty account shows very little.
  • If the app has several roles (user and admin, buyer and seller), create one account per role and put the extra credentials in Notes, as Apple's complete review guidance asks.
  • If the app sells auto-renewable subscriptions, Apple asks for a demo account with an expired subscription, so the reviewer can go through the whole purchase flow.
  • If the reviewer will test account deletion, say in Notes which account to use for it, or give a second account for that - otherwise the next review may find the demo account gone.

3. Handle codes, magic links and social login

  • Email or SMS codes: Apple's guidance is to put any required authentication code in Notes in advance; without it, "a call may be required to continue the review", and Apple says such calls are typically completed within three to five business days (complete review). The simplest route is a demo account that can sign in with a password.
  • Phone sign-in on Supabase: you can add a test phone number with a fixed code under Authentication, Sign In / Providers, Phone, with a Test OTPs Valid Until date (Test auth flows). Supabase warns that anyone who knows the number and code can sign in as that user, so attach it only to the demo account, set the expiry to just after the review, and note that test numbers do not apply to phone MFA.
  • MFA: do not enrol a second factor on the demo account, or explain in Notes how the reviewer gets the code.
  • Google or another single sign-on as the only login: Apple's field reference says to include the demo login for that service (App Review Information). Offering email and password as well gives the reviewer a path that does not depend on another company's checks.
  • If legal or security obligations stop you from providing a demo account at all, 2.1(a) allows a built-in demo mode instead, but only "with prior approval by Apple", and it must show the app's full features.

4. Keep the backend on until the review is done

  • If your Supabase project is paused, click Resume project in the dashboard. Data and configuration come back (Supabase project pausing).
  • A Free plan project can be paused again after a quiet week. If the app is close to launch, the Pro plan removes automatic pausing; otherwise make sure the project sees activity in the days around the review.
  • Make sure the build you submit points at the production project, and that production has the same tables, policies and Edge Functions as the project you tested on.
  • Apple's App Review page says reviews typically complete within 24 hours for at least 50% of submissions and within 48 hours for 90%. Keep the credentials unchanged and the backend running at least until the decision arrives.

5. Update App Store Connect and reply

  1. In App Review Information, tick Sign-in required and enter the demo username and password exactly as you tested them.
  2. In Notes, write the steps a reviewer needs: which account to use for what, where the main features are, anything that needs a code, a QR code or specific hardware.
  3. Test the credentials once more on a fresh TestFlight install, against the production backend.
  4. On the App Review page, use Reply to App Review to say what was wrong and what you changed (Contact App Review), then resubmit. If the binary did not change, you may not need a new build - but if you fixed a backend URL or a login bug in the app, upload a new build first.
Demo account (standard user): review@yourdomain.com / password in the fields above
Admin account: admin-review@yourdomain.com / <password>
The account already contains sample projects, so the dashboard is not empty.
To test account deletion, use: delete-review@yourdomain.com / <password>
No one-time codes or MFA are required for these accounts.
An example of App Review Notes. Replace with your own accounts and steps; keep it under the 4000-byte limit.

When to get help

  • The demo account works for you and the reviewer still reports that they cannot sign in, and you cannot see why.
  • Your login depends on codes, magic links or a single sign-on provider, and you are not sure how to give the reviewer access without weakening security for real users.
  • The release build points at a different backend than you expected, or production is missing tables or functions that exist in development.
  • You have a launch date and cannot afford another rejection cycle.

Sources

Primary documentation this guide was checked against. Platforms change - if something here no longer matches, the source wins.

Frequently asked questions

Does every app with a login need a demo account for App Review?
If the reviewer needs to sign in to use the app, yes. Guideline 2.1(a) asks for demo account info when the app includes a login, and App Store Connect has a Sign-in required section for it. If the app has no significant account-based features, Guideline 5.1.1(v) says to let people use it without a login at all.
Can I give App Review my own account?
You can, but you should not. Use a dedicated account with sample data: it must keep working until the review is done, whatever the reviewer does in it stays there, and it should not contain real personal data.
My app signs in with a magic link or a code. What do I give the reviewer?
The simplest option is a demo account that can sign in with a password. Otherwise Apple asks you to put the authentication code in Notes in advance; without it, App Review may need a call with you, which Apple says typically takes three to five business days. For Supabase phone sign-in, a test phone number with a fixed code works, but treat it like a password and let it expire after the review.
Do I need a new build after fixing the demo account?
Often not, if the problem was only the account or a paused backend, since those are fixed outside the app. Update App Review Information, test the login on the submitted build, reply on the App Review page and resubmit; App Store Connect will tell you if it needs a new build. If the build itself pointed at the wrong backend or had a login bug, upload a fixed build.
Why did the reviewer see an empty screen after signing in?
Either the backend did not answer (a paused Supabase Free plan project, an undeployed function, the wrong project URL in the build) or the demo account has no data. Check the project status in the Supabase dashboard and add sample data to the account.

Related guides

Fixed-price audit

Want someone to check the whole app, not just this?

A review of data security, production readiness and App Store readiness for apps built with AI tools. 900 USD, a ranked list of fixes within 5 business days.