81

So I have this issue where every time I add a new user account, it kicks out the current user that is already signed in. I read the firebase api and it said that "If the new account was created, the user is signed in automatically" But they never said anything else about avoiding that.

      //ADD EMPLOYEES
      addEmployees: function(formData){
        firebase.auth().createUserWithEmailAndPassword(formData.email, formData.password).then(function(data){
          console.log(data);
        });
      },

I'm the admin and I'm adding accounts into my site. I would like it if I can add an account without being signed out and signed into the new account. Any way i can avoid this?

Frank van Puffelen
  • 565,676
  • 79
  • 828
  • 807
Victor Le
  • 1,758
  • 3
  • 17
  • 25
  • 1
    I guess you didn't changed the default setting (prevent user from creating seperate account for each signup) in console while setting up Auth. – Yogesh Jun 03 '16 at 08:10

20 Answers20

134

Update 20161110 - original answer below

Also, check out this answer for a different approach.

Original answer

This is actually possible.

But not directly, the way to do it is to create a second auth reference and use that to create users:

var config = {apiKey: "apiKey",
    authDomain: "projectId.firebaseapp.com",
    databaseURL: "https://databaseName.firebaseio.com"};
var secondaryApp = firebase.initializeApp(config, "Secondary");

secondaryApp.auth().createUserWithEmailAndPassword(em, pwd).then(function(firebaseUser) {
    console.log("User " + firebaseUser.uid + " created successfully!");
    //I don't know if the next statement is necessary 
    secondaryApp.auth().signOut();
});

If you don't specify which firebase connection you use for an operation it will use the first one by default.

Source for multiple app references.

EDIT

For the actual creation of a new user, it doesn't matter that there is nobody or someone else than the admin, authenticated on the second auth reference because for creating an account all you need is the auth reference itself.

The following hasn't been tested but it is something to think about

The thing you do have to think about is writing data to firebase. Common practice is that users can edit/update their own user info so when you use the second auth reference for writing this should work. But if you have something like roles or permissions for that user make sure you write that with the auth reference that has the right permissions. In this case, the main auth is the admin and the second auth is the newly created user.

Bilaal Rashid
  • 828
  • 2
  • 13
  • 21
André Kool
  • 4,880
  • 12
  • 34
  • 44
  • I'm digging this. However, doesn't this still unauthenticate the secondaryApp account (or the mainAppAccount), which would then prevent another user from being created without re-authenticating? – Jay Jun 24 '16 at 15:11
  • @Jay True and a good point, but that actually doesn't matter for the creating of a new user. Anyone can create a user. When I tested this I could create multiple users. However you made me think about something else that could be an issue, writing user data to firebase after creating that user. I'll update my answer to include my thought about that. – André Kool Jun 24 '16 at 18:59
  • @FrankvanPuffelen Please correct my answer if i made any mistakes in the edit i just made. – André Kool Jun 24 '16 at 19:13
  • @FrankvanPuffelen Hmm. I believe that 'anyone can create a user' was changed to 'any authenticated user can create a user' in Firebase 3.x. If you create a user, you are unauth'd - there's no current way around that. Even if you have two connections, at most you could create a user, which unauths' and then use the other account to create a user with would then unauth that account.. Technically you could store login credentials in code to re-auth, but that's a super bad idea. – Jay Jun 24 '16 at 19:15
  • @Jay: creating an account now signs the previously signed-in user out. But unauthenticated users can still create an account. – Frank van Puffelen Jun 24 '16 at 19:17
  • 3
    @FrankvanPuffelen Well shut my mouth. That's correct (of course). Which then leads to the question; why make the change that was made to start with? Kinda seems counter-intuitive to unauth an auth'd account that's creating a user when anyone can still create accounts. Weird. Anyway, this is a *BRILLIANT* answer. – Jay Jun 24 '16 at 19:39
  • 11
    This really helped me a lot, thanks!. One thing to add is that I had to add 'secondaryApp.delete();' to stop firebase from telling me that there's another app registered globally. – Jimmy Jul 02 '16 at 02:49
  • Do both instances use the same config? – Travis Christian Aug 01 '16 at 15:29
  • @TravisChristian yes – André Kool Aug 01 '16 at 15:56
  • 2
    @AndréKool: we just released a firebase-admin SDK, which makes it unneeded to use your (admittedly clever) workaround. See [my updated answer below](http://stackoverflow.com/a/37614090/209103). – Frank van Puffelen Nov 08 '16 at 11:56
  • @AndréKool I am using ionic 3 and facing same problem but got confused where to add the above code? I have added it in constructor of working page but it gives me error --- secondaryApp.createUserMethod() not found and page is reloading since i am testing it on browser. – Raj Oct 22 '18 at 13:00
  • Can you please tell me a solution for Java android Studio – Matt Dec 12 '18 at 07:27
  • @AndréKool, This workaround is nice, but I was wondering how we could go further? How I could edit/update or delete a given user? There are even functions available for that? – Hunor Nov 05 '19 at 11:34
23

Update 20161108 - original answer below

Firebase just released its firebase-admin SDK, which allows server-side code for this and other common administrative use-cases. Read the installation instructions and then dive into the documentation on creating users.

original answer

This is currently not possible. Creating an Email+Password user automatically signs that new user in.

Frank van Puffelen
  • 565,676
  • 79
  • 828
  • 807
  • Frank , So I Should use Firebase admin SDK in my AngularJS App if I want to create users without Signing them in? – Zaid Mirza Nov 08 '16 at 12:46
  • 1
    The Firebase Admin node.js SDK should be run in a trusted environment only. Creating a user without signing them in is considered an administrative task. – Frank van Puffelen Nov 08 '16 at 13:05
  • 4
    @FrankvanPuffelen I want the mobile app user to be able to invite user which uses the `createUserWithEmailAndPassword` and sends email to the user. I don't want to use the firebase-admin SDK in the client-side/mobile app.What are my other options? – alltej Sep 19 '17 at 21:33
  • Ok, so I just spent a few hours studying Node.js, set up a service to handle the Post data from the new user form from an angular2 project, the logged-in user doesn't get booted out :). Now to implement delete and update. – Ivan Oct 24 '17 at 22:16
  • 2
    @FrankvanPuffelen Is there a reason why you guys don't add a `noLogin` flag to `createUserWithEmailAndPassword`? Like many others I also need to add users from my frontend without using Admin SDK. – Obiwahn Oct 09 '19 at 08:35
  • The client-side SDK is meant to be used for individual users, not for administrative tasks. Also see bojeil's comments here https://github.com/firebase/firebase-js-sdk/issues/1513 – Frank van Puffelen Oct 09 '19 at 14:19
  • I'd suggest using a Firebase Function like "createUser()" that you call from your client. On the backend this function can check that the user who called it has the right roles to do that operation and use the Admin SDK to create it. – Anth0 Jun 15 '20 at 08:28
14

I just created a Firebase Function that triggers when a Firestore document is Created (with rules write-only to admin user). Then use admin.auth().createUser() to create the new user properly.

export const createUser = functions.firestore
.document('newUsers/{userId}')
.onCreate(async (snap, context) => {
    const userId = context.params.userId;
    const newUser = await admin.auth().createUser({
        disabled: false,
        displayName: snap.get('displayName'),
        email: snap.get('email'),
        password: snap.get('password'),
        phoneNumber: snap.get('phoneNumber')
    });
    // You can also store the new user in another collection with extra fields
    await admin.firestore().collection('users').doc(newUser.uid).set({
        uid: newUser.uid,
        email: newUser.email,
        name: newUser.displayName,
        phoneNumber: newUser.phoneNumber,
        otherfield: snap.get('otherfield'),
        anotherfield: snap.get('anotherfield')
    });
    // Delete the temp document
    return admin.firestore().collection('newUsers').doc(userId).delete();
});

You can Algo use functions.https.onCall()

exports.createUser= functions.https.onCall((data, context) => {
    const uid = context.auth.uid; // Authorize as you want
    // ... do the same logic as above
});

calling it.

const createUser = firebase.functions().httpsCallable('createUser');
createUser({userData: data}).then(result => {
    // success or error handling
});
11

Swift 5: Simple Solution

First store the current user in a variable called originalUser

let originalUser = Auth.auth().currentUser

Then, in the completion handler of creating a new user, use the updateCurrentUser method to restore the original user

Auth.auth().updateCurrentUser(originalUser, completion: nil)
Community
  • 1
  • 1
caesic
  • 181
  • 2
  • 3
7

Here is a simple solution using web SDKs.

  1. Create a cloud function (https://firebase.google.com/docs/functions)
import admin from 'firebase-admin';
import * as functions from 'firebase-functions';

const createUser = functions.https.onCall((data) => {
  return admin.auth().createUser(data)
    .catch((error) => {
      throw new functions.https.HttpsError('internal', error.message)
    });
});

export default createUser;
  1. Call this function from your app
import firebase from 'firebase/app';

const createUser = firebase.functions().httpsCallable('createUser');

createUser({ email, password })
  .then(console.log)
  .catch(console.error);
  1. Optionally, you can set user document information using the returned uid.
createUser({ email, password })
  .then(({ data: user }) => {
    return database
      .collection('users')
      .doc(user.uid)
      .set({
        firstname,
        lastname,
        created: new Date(),
      });
  })
  .then(console.log)
  .catch(console.error);
Jon Sakas
  • 2,042
  • 1
  • 21
  • 26
  • This is the solution I like the best, but it gets blocked by CORS? – Davtho1983 May 22 '20 at 17:21
  • @Davtho1983 sounds like you need to adjust the cloud function settings which is unspecific to this answer: https://cloud.google.com/functions/docs/writing/http#handling_cors_requests – Jon Sakas May 22 '20 at 17:24
  • Gud solution to add user to the authenticate section instead of firestore <3 – Gopal Jun 24 '20 at 02:43
3

I got André's very clever workaround working in Objective-C using the Firebase iOS SDK:

NSString *plistPath = [[NSBundle mainBundle] pathForResource:@"GoogleService-Info" ofType:@"plist"];
FIROptions *secondaryAppOptions = [[FIROptions alloc] initWithContentsOfFile:plistPath];
[FIRApp configureWithName:@"Secondary" options:secondaryAppOptions];
FIRApp *secondaryApp = [FIRApp appNamed:@"Secondary"];
FIRAuth *secondaryAppAuth = [FIRAuth authWithApp:secondaryApp];

[secondaryAppAuth createUserWithEmail:user.email
                             password:user.password
                           completion:^(FIRUser * _Nullable user, NSError * _Nullable error) {
                                [secondaryAppAuth signOut:nil];
                          }];
André Kool
  • 4,880
  • 12
  • 34
  • 44
Jonathan Cabrera
  • 1,656
  • 1
  • 19
  • 20
2

Update for Swift 4

I have tried a few different options to create multiple users from a single account, but this is by far the best and easiest solution.

Original answer by Nico

First Configure firebase in your AppDelegate.swift file

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
    // Override point for customization after application launch.
    FirebaseApp.configure()
    FirebaseApp.configure(name: "CreatingUsersApp", options: FirebaseApp.app()!.options)

    return true
}

Add the following code to action where you are creating the accounts.

            if let secondaryApp = FirebaseApp.app(name: "CreatingUsersApp") {
                let secondaryAppAuth = Auth.auth(app: secondaryApp)
                
                // Create user in secondary app.
                secondaryAppAuth.createUser(withEmail: email, password: password) { (user, error) in
                    if error != nil {
                        print(error!)
                    } else {
                        //Print created users email.
                        print(user!.email!)
                        
                        //Print current logged in users email.
                        print(Auth.auth().currentUser?.email ?? "default")
                        
                        try! secondaryAppAuth.signOut()
                        
                    }
                }
            }
        }
Community
  • 1
  • 1
B.Slade
  • 143
  • 1
  • 8
2

You can use firebase function for add users.

const functions = require('firebase-functions');
const admin = require('firebase-admin');
admin.initializeApp();

const cors = require('cors')({
origin: true,
});
exports.AddUser = functions.https.onRequest(( req, res ) => {
// Grab the text parameter.

cors( req, res, ()  => {
    let email  = req.body.email;
    let passwd = req.body.passwd;
    let role   = req.body.role;
    const token = req.get('Authorization').split('Bearer ')[1];

    admin.auth().verifyIdToken(token)
    .then(
            (decoded) => { 
             // return res.status(200).send(  decoded )
             return creatUser(decoded);
            })
    .catch((err) => {
            return res.status(401).send(err) 
     });
       
    function creatUser(user){
      admin.auth().createUser({
          email: email,
          emailVerified: false,
          password: passwd,
          disabled: false
        })
        .then((result) => {
          console.log('result',result);
           return res.status(200).send(result);
        }).catch((error) => {
           console.log(error.message);
           return res.status(400).send(error.message);
       })
     }

   }); 
 });

  CreateUser(){
//console.log('Create User')
this.submitted = true;
if (this.myGroup.invalid) {
  return;
}


let Email    = this.myGroup.value.Email;
let Passwd   = this.myGroup.value.Passwd;
let Role     = 'myrole';
let TechNum  = this.myGroup.value.TechNum;
let user     = JSON.parse(localStorage.getItem('user'));
let role     = user.role;
let AdminUid = user.uid;
let authToken = user.stsTokenManager.accessToken;
let httpHeaders = new HttpHeaders().set('Authorization', 'Bearer ' + authToken);
let options = { headers: httpHeaders };
let params  = { email:Email,passwd:Passwd,role:Role };

this.httpClient.post('https://us-central1-myproject.cloudfunctions.net/AddUser', params, options)
.subscribe( val => { 
           //console.log('Response from cloud function', val ); 
           let createdUser:any = val;
           //console.log(createdUser.uid);
           const userRef: AngularFirestoreDocument<any> = this.afs.doc(`users/${createdUser.uid}`);
                 const userUpdate = {
                             uid: createdUser.uid,
                             email: createdUser.email,
                             displayName: null,
                             photoURL: null,
                             emailVerified: createdUser.emailVerified,
                             role: Role,
                             TechNum:TechNum,
                             AccountAccess:this.AccountAccess,
                             UserStatus:'open',
                             OwnerUid:AdminUid,
                             OwnerUidRole:role,
                             RootAccountAccess:this.RootAccountAccess
                      }
                       userRef.set(userUpdate, {
                             merge: false
                       });
                          this.toastr.success('Success, user add','Success');
                          this.myGroup.reset();
                          this.submitted = false;
                       },
                       err => { 
                         console.log('HTTP Error', err.error)
                         this.toastr.error(err.error,'Error')
                       },
                       () => console.log('HTTP request completed.')
    );

}

1

On the web, this is due to unexpected behavior when you call createUserWithEmailAndPassword out of the registration context; e.g. inviting a new user to your app by creating a new user account.

Seems like, createUserWithEmailAndPassword method triggers a new refresh token and user cookies are updated too. (This side-effect is not documented)

Here is a workaround for Web SDK: After creating the new user;

firebase.auth().updateCurrentUser (loggedInUser.current)

provided that you initiate loggedInUser with the original user beforehand.

Mike Bahar
  • 26
  • 2
1

Hey i had similar problem ,trying to create users through admin , as it is not possible to signUp user without signIn ,I created a work around ,adding it below with steps

  1. Instead of signup create a node in firebase realtime db with email as key (firebase do not allow email as key so I have created a function to generate key from email and vice versa, I will attach the functions below)
  2. Save a initial password field while saving user (can even hash it with bcrypt or something, if you prefer though it will be used one time only)
  3. Now Once user try to login check if any node with that email (generate key from email) exist in the db and if so then match the password provided.
  4. If the password matched delete the node and do authSignUpWithEmailandPassword with provided credentials.
  5. User is registered successfully
//Sign In
firebaseDB.child("users").once("value", (snapshot) => {
     const users = snapshot.val();
     const userKey = emailToKey(data.email);
     if (Object.keys(users).find((key) => key === userKey)) {
       setError("user already exist");
       setTimeout(() => {
         setError(false);
       }, 2000);
       setLoading(false);
     } else {
       firebaseDB
         .child(`users`)
         .child(userKey)
         .set({ email: data.email, initPassword: data.password })
         .then(() => setLoading(false))
         .catch(() => {
           setLoading(false);
           setError("Error in creating user please try again");
           setTimeout(() => {
             setError(false);
           }, 2000);
         });
     }
   });

//Sign Up 
signUp = (data, setLoading, setError) => {
 auth
   .createUserWithEmailAndPassword(data.email, data.password)
   .then((res) => {
     const userDetails = {
       email: res.user.email,
       id: res.user.uid,
     };
     const key = emailToKey(data.email);
     app
       .database()
       .ref(`users/${key}`)
       .remove()
       .then(() => {
         firebaseDB.child("users").child(res.user.uid).set(userDetails);
         setLoading(false);
       })
       .catch(() => {
         setLoading(false);
         setError("error while registering try again");
         setTimeout(() => setError(false), 4000);
       });
   })
   .catch((err) => {
     setLoading(false);
     setError(err.message);
     setTimeout(() => setError(false), 4000);
   });
};

//Function to create a valid firebase key from email and vice versa
const emailToKey = (email) => {
 //firebase do not allow ".", "#", "$", "[", or "]"
 let key = email;
 key = key.replace(".", ",0,");
 key = key.replace("#", ",1,");
 key = key.replace("$", ",2,");
 key = key.replace("[", ",3,");
 key = key.replace("]", ",4,");

 return key;
};

const keyToEmail = (key) => {
 let email = key;
 email = email.replace(",0,", ".");
 email = email.replace(",1,", "#");
 email = email.replace(",2,", "$");
 email = email.replace(",3,", "[");
 email = email.replace(",4,", "]");

 return email;
};
Aadarsh
  • 41
  • 3
1

If you want to do it in your front end create a second auth reference use it to create other users and sign out and delete that reference. If you do it this way you won't be signed out when creating a new user and you won't get the error that the default firebase app already exists.

   const createOtherUser =()=>{
            var config = {
                //your firebase config
            };
            let secondaryApp = firebase.initializeApp(config, "secondary");

            secondaryApp.auth().createUserWithEmailAndPassword(email, password).then((userCredential) => {
                console.log(userCredential.user.uid);
            }).then(secondaryApp.auth().signOut()
            )
            .then(secondaryApp.delete()
            )


        }
        
raphael
  • 21
  • 2
1

Update 19.05.2022 - using @angular/fire (latest available = v.7.3.0)

If you are not using firebase directly in your app, but use e.g. @angular/fire for auth purposes only, you can use the same approach as suggested earlier as follows with the @angular/fire library:

import { Auth, getAuth, createUserWithEmailAndPassword } from '@angular/fire/auth';
import { deleteApp, initializeApp } from '@angular/fire/app';
import { firebaseConfiguration } from '../config/app.config';   // <-- Your project's configuration here.


const tempApp = initializeApp(firebaseConfiguration, "tempApp");
const tempAppAuth = getAuth(tempApp);
await createUserWithEmailAndPassword(tempAppAuth, email, password)
.then(async (newUser) => {
    resolve( () ==>  {
        // Do something, e.g. add user info to database
    });
})
.catch(error => reject(error))
.finally( () => {
    tempAppAuth.signOut()
    .then( () => deleteApp(tempApp)); 
});
El Fred
  • 330
  • 1
  • 7
  • 23
0

The Swift version:

FIRApp.configure()

// Creating a second app to create user without logging in
FIRApp.configure(withName: "CreatingUsersApp", options: FIRApp.defaultApp()!.options)

if let secondaryApp = FIRApp(named: "CreatingUsersApp") {
    let secondaryAppAuth = FIRAuth(app: secondaryApp)
    secondaryAppAuth?.createUser(...)
}
Nico
  • 6,269
  • 9
  • 45
  • 85
0

Here is a Swift 3 adaptaion of Jcabrera's answer :

let bundle = Bundle.main
        let path = bundle.path(forResource: "GoogleService-Info", ofType: "plist")!
        let options = FIROptions.init(contentsOfFile: path)
        FIRApp.configure(withName: "Secondary", options: options!)
        let secondary_app = FIRApp.init(named: "Secondary")
        let second_auth = FIRAuth(app : secondary_app!)
        second_auth?.createUser(withEmail: self.username.text!, password: self.password.text!)
        {
            (user,error) in
            print(user!.email!)
            print(FIRAuth.auth()?.currentUser?.email ?? "default")
        }
Community
  • 1
  • 1
sanket pahuja
  • 325
  • 2
  • 12
0

If you are using Polymer and Firebase (polymerfire) see this answer: https://stackoverflow.com/a/46698801/1821603

Essentially you create a secondary <firebase-app> to handle the new user registration without affecting the current user.

Evan Caldwell
  • 153
  • 2
  • 14
0

Android solution (Kotlin):

1.You need FirebaseOptions BUILDER(!) for setting api key, db url, etc., and don't forget to call build() at the end

2.Make a secondary auth variable by calling FirebaseApp.initializeApp()

3.Get instance of FirebaseAuth by passing your newly created secondary auth, and do whatever you want (e.g. createUser)

    // 1. you can find these in your project settings under general tab
    val firebaseOptionsBuilder = FirebaseOptions.Builder()
    firebaseOptionsBuilder.setApiKey("YOUR_API_KEY")
    firebaseOptionsBuilder.setDatabaseUrl("YOUR_DATABASE_URL")
    firebaseOptionsBuilder.setProjectId("YOUR_PROJECT_ID")
    firebaseOptionsBuilder.setApplicationId("YOUR_APPLICATION_ID") //not sure if this one is needed
    val firebaseOptions = firebaseOptionsBuilder.build()

    // indeterminate progress dialog *ANKO*
    val progressDialog = indeterminateProgressDialog(resources.getString(R.string.progressDialog_message_registering))
    progressDialog.show()

    // 2. second auth created by passing the context, firebase options and a string for secondary db name
    val newAuth = FirebaseApp.initializeApp(this@ListActivity, firebaseOptions, Constants.secondary_db_auth)
    // 3. calling the create method on our newly created auth, passed in getInstance
    FirebaseAuth.getInstance(newAuth).createUserWithEmailAndPassword(email!!, password!!)
    .addOnCompleteListener { it ->

        if (it.isSuccessful) {

            // 'it' is a Task<AuthResult>, so we can get our newly created user from result
            val newUser = it.result.user

            // store wanted values on your user model, e.g. email, name, phonenumber, etc.
            val user = User()
            user.email = email
            user.name = name
            user.created = Date().time
            user.active = true
            user.phone = phone

            // set user model on /db_root/users/uid_of_created_user/, or wherever you want depending on your structure
            FirebaseDatabase.getInstance().reference.child(Constants.db_users).child(newUser.uid).setValue(user)

            // send newly created user email verification link
            newUser.sendEmailVerification()

            progressDialog.dismiss()

            // sign him out
            FirebaseAuth.getInstance(newAuth).signOut()
            // DELETE SECONDARY AUTH! thanks, Jimmy :D
            newAuth.delete()

        } else {

            progressDialog.dismiss()

            try {

                throw it.exception!!

                // catch exception for already existing user (e-mail)
            } catch (e: FirebaseAuthUserCollisionException) {

                alert(resources.getString(R.string.exception_FirebaseAuthUserCollision), resources.getString(R.string.alertDialog_title_error)) {

                    okButton {

                        isCancelable = false

                    }

                }.show()

            }

        }

    }
fkvestak
  • 539
  • 7
  • 20
0

For Android, i suggest a simpler way to do it, without having to provide api key, application id...etc by hand by just using the FirebaseOptions of the default instance.

val firebaseDefaultApp = Firebase.auth.app
val signUpAppName = firebaseDefaultApp.name + "_signUp"

val signUpApp = try {
    FirebaseApp.initializeApp(
        context,
        firebaseDefaultApp.options,
        signUpAppName
    )
} catch (e: IllegalStateException) {
    // IllegalStateException is throw if an app with the same name has already been initialized.
    FirebaseApp.getInstance(signUpAppName)
}

// Here is the instance you can use to sign up without triggering auth state on the default Firebase.auth
val signUpFirebaseAuth = Firebase.auth(signUpApp)

How to use ?

signUpFirebaseAuth
            .createUserWithEmailAndPassword(email, password)
            .addOnSuccessListener {
                // Optional, you can send verification email here if you need

                // As soon as the sign up with sign in is over, we can sign out the current user
                firebaseAuthSignUp.signOut()
            }
            .addOnFailureListener {
                // Log
            }
DamienL
  • 577
  • 1
  • 5
  • 14
0

My solution to this question is to store the User Name/Email and password in a static class and then add a new user log out the new user and immediately log in as the admin user(id pass you saved). Works like a charm for me :D

The Flash
  • 59
  • 7
0

This is a version for Kotlin:

    fun createUser(mail: String, password: String) {
        val opts = FirebaseOptions.fromResource(requireContext())
        if (opts == null) return
        val app = Firebase.initialize(requireContext(), opts, "Secondary")
        FirebaseAuth.getInstance(app)
            .createUserWithEmailAndPassword(mail, password)
            .addOnSuccessListener {
                app.delete()
                doWhateverWithAccount(it)
            }.addOnFailureListener {
                app.delete()
                showException(it)
            }
    }

It uses the configuration from your default Firebase application instance, just under a different name. It also deletes the newly created instance afterwards, so you can call this multiple times without any exception about already existing Secondary application.

Oliver Hoffmann
  • 146
  • 2
  • 11
0

Try using firebase auth REST APIs to create the user. You can query the Firebase Auth backend through a REST API. This can be used for various operations such as creating new users, signing in existing ones and editing or deleting these users.

https://firebase.google.com/docs/reference/rest/auth#section-create-email-password

Nikhil
  • 861
  • 11
  • 15