Staticbot logoStaticbot.dev
    Migration guides

    November 7, 2026 · Updated November 8, 2026 · Sign-in after AI builders · 9 min read

    Keep “Continue with Google” Working After You Leave Lovable or Base44

    On Lovable Cloud and Base44, Google sign-in usually runs on the builder's own OAuth client, and that client stays behind when your app moves to your own Supabase. Here is how to set up a Google client you own, connect it to Supabase, and keep every existing user's account.

    By , Co-founder of StaticbotLinkedIn

    Ravel works on Staticbot’s migration platform, moving apps built with Lovable and Base44 onto Supabase and hosting their owners control.

    Your app now runs on a Supabase project you own. Email sign-in works. Then someone clicks “Continue with Google” and gets an error, or the button is gone.

    Nothing in your code broke. On the builder, that button ran on an OAuth client the builder registered with Google, and that client stays with the builder. You need one of your own. Setting it up takes about 20 minutes, needs no Google review for plain sign-in, and your existing users keep their accounts.

    Why Google sign-in doesn't move with your app

    Three things have to line up for “Continue with Google” to work:

    • An OAuth client registered in Google Cloud. Its owner decides the branding and which addresses Google may send people back to.
    • A callback: the address Google returns the user to after they pick an account. With Supabase, that is your Supabase project's own callback, not your app.
    • The sign-in call in your app's code, which starts the flow.

    On both builders, the default setup puts at least one of these on the builder's side:

    What Google sign-in runs on, and what you set up after moving
    Where the app came fromGoogle sign-in usedWhat you set up on your Supabase
    Lovable Cloud, “Managed by Lovable” (the default)Lovable's OAuth client, through Lovable's sign-in libraryA Google client you own, Supabase's Google provider, and a small code change
    Lovable Cloud with your own credentialsYour client, registered for Lovable's sign-in flowReuse the client and add your Supabase callback. Same code change
    Lovable connected to your own SupabaseYour client, on your old Supabase projectEnter the same client ID and secret on the new project and add its callback
    Base44, default Google loginBase44's OAuth client (the sign-in window names base44.com)A Google client you own and Supabase's Google provider
    Base44, custom Google OAuthYour client, registered for Base44's callbackReuse the client and add your Supabase callback

    Both builders document the two options: Lovable in its Google authentication guide, Base44 under managing login and registration. Base44's custom option needs a Builder plan or higher and registers https://app.base44.com/api/apps/auth/callback, so even a client you already own still sends people back to Base44 until you add your Supabase callback.

    Before you start

    • Access to a Google Cloud project. Reusing a project you already have, for example the one behind a Google Calendar integration, is fine.
    • Your Supabase project reference: the <project-ref> in https://<project-ref>.supabase.co.
    • The addresses your app runs on: the preview you test on now, and the production domain you will go live on.

    Step 1: Create a Google OAuth client you own

    In the Google Cloud console, open Google Auth Platform.

    1. Branding: enter your app's name, a support email, your home page, and your privacy policy and terms pages. Add your production domain under authorized domains.
    2. Audience: choose External so anyone with a Google account can sign in.
    3. Data Access: make sure the scopes are openid, .../auth/userinfo.email and .../auth/userinfo.profile. Supabase's Google guide notes that openid has to be added by hand.
    4. Clients → Create client → Web application:
      • Under Authorized JavaScript origins, add your app's addresses: the preview and the production domain.
      • Under Authorized redirect URIs, add exactly one address: https://<project-ref>.supabase.co/auth/v1/callback. This is the most common mistake. Google sends people to Supabase, and Supabase sends them on to your app.

    Copy the client ID and client secret.

    If the same project also runs a per-user integration such as Google Calendar, create a separate client for sign-in. Then you can change either one without affecting the other.

    Plain sign-in needs no Google review. Google's audience settings exempt apps that ask only for name, email address and profile from the test-user list and the unverified-app warning, even while publishing status is still Testing.

    Step 2: Turn on Google in your Supabase project

    1. Go to Authentication → Sign In / Providers → Google, switch it on, and paste the client ID and secret. The callback URL shown on that page must match what you entered in Google Cloud.
    2. Go to Authentication → URL Configuration and add every address your app returns people to under Redirect URLs: your preview, for example https://preview.example.net/**, and later your production domain. Supabase's redirect URL rules explain the wildcards and recommend exact addresses for production.
    3. Set the Site URL to your production domain when you go live. Supabase uses it whenever no other return address is given, and in email confirmations and password resets.

    Step 3: Point your app's Google button at Supabase

    The sign-in call is the same on any Supabase project:

    const { error } = await supabase.auth.signInWithOAuth({
      provider: 'google',
      options: { redirectTo: window.location.origin + '/' },
    });
    if (error) throw error;

    Google sends the user to Supabase, Supabase sends them to redirectTo, and the Supabase client picks up the session from the address on its own.

    • Lovable Cloud apps sign in through Lovable's library, @lovable.dev/cloud-auth-js, in the generated src/integrations/lovable/index.ts. A call like lovable.auth.signInWithOAuth("google", …) only works on Lovable's hosting. Migrating with Staticbot replaces that file with one that keeps the same lovable.auth.signInWithOAuth interface and calls your Supabase instead, so the rest of your login code stays as it is. If you changed the file or the code calling it, Staticbot leaves it alone and names the file: replace those calls with the one above.
    • Lovable apps already on your own Supabase usually call supabase.auth.signInWithOAuth already. Nothing to change.
    • Base44 apps migrated with Staticbot keep their code: the compatibility layer turns base44.auth.loginWithProvider('google', returnTo) into this same Supabase call. If your app has its own login page, its Google button works as soon as Step 2 is done.

    Step 4: Test it with real accounts

    1. Signed out, open your preview and click “Continue with Google”. Google's account chooser should appear.
    2. Sign in with a Google account whose email already belongs to a user in your app. You should land in that user's own data, not an empty account.
    3. Sign in with a Google account that has no account in your app. Check that the result matches your sign-up rules: a new account if anyone may join, a clear refusal if the app is invite-only.
    4. Sign out, then sign in as the same user with email. It should be the same account.
    What the common errors mean
    You seeLikely cause
    redirect_uri_mismatch on Google's pageThe redirect URI in Google Cloud isn't exactly your Supabase callback.
    “Unsupported provider: provider is not enabled”Google isn't switched on in this Supabase project. Check you configured the project the app actually uses.
    Signed in, but back on the wrong pageThe address the app asked to return to isn't in Supabase's Redirect URLs.
    “Access blocked” for some accountsThe Google project asks for more than name, email and profile while still in Testing. Publish it, or add those users as test users.

    Will existing users keep their accounts?

    Yes, as long as they use the same email. Supabase links identities automatically: when someone signs in with Google, it looks for an existing user with the same email address and attaches the Google sign-in to that user. It won't link to an unverified email address.

    • From Base44: Base44 keeps password hashes on its platform, so accounts move by email and are marked as confirmed. People sign in with an emailed code, or with Google once it is set up. Either way they reach the same account and data.
    • From Lovable: users, password hashes and existing Google sign-in records move with your database, so people keep their passwords as well. Returning Google users reach the same account.

    The exception is someone whose Google address differs from the email they used in your app. Signing in with Google creates a separate, empty account for them. If that applies to some of your users, tell them to sign in by email the first time.

    Before you go live on your own domain

    • Return addresses: add the production domain to Supabase's Redirect URLs and make it the Site URL. If Staticbot hosts the app, this happens automatically when the domain goes live.
    • Google client: add the production domain to the JavaScript origins. The redirect URI stays your Supabase callback.
    • Publishing status: if the Google project requests more than name, email and profile, for example calendar access, publish it to In production before launch.
    • The name on Google's account chooser: until you change it, Google names your Supabase address (<project-ref>.supabase.co). A Supabase custom domain, a paid add-on on paid plans, puts your own domain there. Add its callback in Google Cloud alongside the original one. Google's brand verification, which can take a few business days, lets the chooser show your app's name and logo.
    • Timing: keep sign-in on the builder working until you switch domains. The live migration guide covers the cutover.

    Quick answers

    Can I reuse my existing Google Cloud project? Yes. Create a new web client in it for sign-in, or reuse a client you already own for sign-in and add your Supabase callback to it.

    Do users need to reconnect anything? No. Signing in with Google is not a stored connection; users just sign in. Per-user integrations such as Gmail or Calendar access are different and need a reconnect after a move. See keeping per-user integrations working.

    Is “Sign in with Google” the same as Google Calendar access? No. Sign-in only proves who someone is. Calendar or Gmail access is a separate permission with its own scopes and, often, Google review.

    How Staticbot handles this

    When Staticbot migrates your app to your own Supabase, sign-in keeps working from the first minute:

    • Base44 apps: every user is moved by email, and the login page Base44 hosted is recreated in your app with email-code sign-in. Once your Google client is set up in Supabase, the project's Sync tab offers a platform update that adds the Google button to that page. Apply it and the preview rebuilds with the button.
    • Lovable apps: users, password hashes and Google sign-in records move with your data, and the sign-in code Lovable generated is switched to your Supabase. Apps migrated earlier get the same change as a platform update in the Sync tab. You add your Google client as described above.
    • Going live: with Staticbot's affordable hosting, the Supabase Site URL and redirect list follow your production domain when it goes live. Everything still runs on a backend you own.

    Start with the Lovable migration guide or the Base44 migration guide, or check your app with Staticbot.