Catch up on everything announced at Firebase Summit, and learn how Firebase can help you accelerate app development and run your app with confidence. Learn More

Administrar usuarios

Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

El SDK de Firebase Admin proporciona una API para administrar sus usuarios de Firebase Authentication con privilegios elevados. La API de administración de usuarios de administrador le brinda la capacidad de completar mediante programación las siguientes tareas desde un entorno de servidor seguro:

  • Cree nuevos usuarios sin ningún tipo de regulación o limitación de velocidad.
  • Busque usuarios por diferentes criterios, como uid, correo electrónico o número de teléfono.
  • Enumere todos los usuarios de un proyecto específico en lotes.
  • Acceda a los metadatos del usuario, incluida la fecha de creación de la cuenta y la última fecha de inicio de sesión.
  • Elimine usuarios sin solicitar su contraseña existente.
  • Actualice las propiedades del usuario, incluida su contraseña, sin tener que iniciar sesión como usuario.
  • Verifique los correos electrónicos sin tener que pasar por los flujos de acción fuera de banda para verificar los correos electrónicos.
  • Cambie el correo electrónico de un usuario sin enviar enlaces de correo electrónico para revocar estos cambios.
  • Cree un nuevo usuario con un número de teléfono sin tener que pasar por el flujo de verificación de SMS.
  • Cambie el número de teléfono de un usuario sin tener que pasar por el flujo de verificación de SMS.
  • Aprovisione a los usuarios sin conexión en un estado deshabilitado y luego controle cuándo habilitarlos.
  • Cree consolas de usuario personalizadas que se adapten al sistema de administración de usuarios de una aplicación específica.

Antes de que empieces

Para usar la API de administración de usuarios proporcionada por Firebase Admin SDK, debe tener una cuenta de servicio. Siga las instrucciones de configuración para obtener más información sobre cómo inicializar el SDK de administrador.

Recuperar datos de usuario

La forma principal de identificar a un usuario es por su uid , un identificador único para ese usuario. Admin SDK proporciona un método que permite obtener la información de perfil de los usuarios por su uid :

Nodo.js

getAuth()
  .getUser(uid)
  .then((userRecord) => {
    // See the UserRecord reference doc for the contents of userRecord.
    console.log(`Successfully fetched user data: ${userRecord.toJSON()}`);
  })
  .catch((error) => {
    console.log('Error fetching user data:', error);
  });

Java

UserRecord userRecord = FirebaseAuth.getInstance().getUser(uid);
// See the UserRecord reference doc for the contents of userRecord.
System.out.println("Successfully fetched user data: " + userRecord.getUid());

Pitón

from firebase_admin import auth

user = auth.get_user(uid)
print('Successfully fetched user data: {0}'.format(user.uid))

Vamos

// Get an auth client from the firebase.App
client, err := app.Auth(ctx)
if err != nil {
	log.Fatalf("error getting Auth client: %v\n", err)
}

u, err := client.GetUser(ctx, uid)
if err != nil {
	log.Fatalf("error getting user %s: %v\n", uid, err)
}
log.Printf("Successfully fetched user data: %v\n", u)

C#

UserRecord userRecord = await FirebaseAuth.DefaultInstance.GetUserAsync(uid);
// See the UserRecord reference doc for the contents of userRecord.
Console.WriteLine($"Successfully fetched user data: {userRecord.Uid}");

Este método devuelve un objeto UserRecord para el usuario correspondiente al uid proporcionado al método.

Si el uid proporcionado no pertenece a un usuario existente o el usuario no se puede recuperar por cualquier otro motivo, el método anterior genera un error. Para obtener una lista completa de los códigos de error, incluidas las descripciones y los pasos de resolución, consulte Errores de la API de autenticación de administrador .

En algunos casos, tendrá el correo electrónico de un usuario en lugar de su uid . El SDK de administración de Firebase admite la búsqueda de información de usuario con un correo electrónico:

Nodo.js

getAuth()
  .getUserByEmail(email)
  .then((userRecord) => {
    // See the UserRecord reference doc for the contents of userRecord.
    console.log(`Successfully fetched user data: ${userRecord.toJSON()}`);
  })
  .catch((error) => {
    console.log('Error fetching user data:', error);
  });

Java

UserRecord userRecord = FirebaseAuth.getInstance().getUserByEmail(email);
// See the UserRecord reference doc for the contents of userRecord.
System.out.println("Successfully fetched user data: " + userRecord.getEmail());

Pitón

from firebase_admin import auth

user = auth.get_user_by_email(email)
print('Successfully fetched user data: {0}'.format(user.uid))

Vamos

u, err := client.GetUserByEmail(ctx, email)
if err != nil {
	log.Fatalf("error getting user by email %s: %v\n", email, err)
}
log.Printf("Successfully fetched user data: %v\n", u)

C#

UserRecord userRecord = await FirebaseAuth.DefaultInstance.GetUserByEmailAsync(email);
// See the UserRecord reference doc for the contents of userRecord.
Console.WriteLine($"Successfully fetched user data: {userRecord.Uid}");

Este método devuelve un objeto UserRecord para el usuario correspondiente al correo electrónico proporcionado.

Si el correo electrónico proporcionado no pertenece a un usuario existente o el usuario no se puede recuperar por cualquier otro motivo, el SDK de administrador genera un error. Para obtener una lista completa de los códigos de error, incluidas las descripciones y los pasos de resolución, consulte Errores de API de autenticación de administrador .

En otros casos, tendrá el número de teléfono de un usuario en lugar de su uid . El SDK de administración de Firebase admite la búsqueda de información de usuario con un número de teléfono:

Nodo.js

getAuth()
  .getUserByPhoneNumber(phoneNumber)
  .then((userRecord) => {
    // See the UserRecord reference doc for the contents of userRecord.
    console.log(`Successfully fetched user data:  ${userRecord.toJSON()}`);
  })
  .catch((error) => {
    console.log('Error fetching user data:', error);
  });

Java

UserRecord userRecord = FirebaseAuth.getInstance().getUserByPhoneNumber(phoneNumber);
// See the UserRecord reference doc for the contents of userRecord.
System.out.println("Successfully fetched user data: " + userRecord.getPhoneNumber());

Pitón

from firebase_admin import auth

user = auth.get_user_by_phone_number(phone)
print('Successfully fetched user data: {0}'.format(user.uid))

Vamos

u, err := client.GetUserByPhoneNumber(ctx, phone)
if err != nil {
	log.Fatalf("error getting user by phone %s: %v\n", phone, err)
}
log.Printf("Successfully fetched user data: %v\n", u)

C#

UserRecord userRecord = await FirebaseAuth.DefaultInstance.GetUserByPhoneNumberAsync(phoneNumber);
// See the UserRecord reference doc for the contents of userRecord.
Console.WriteLine($"Successfully fetched user data: {userRecord.Uid}");

Este método devuelve un objeto UserRecord para el usuario correspondiente al número de teléfono proporcionado.

Si el número de teléfono proporcionado no pertenece a un usuario existente o el usuario no se puede recuperar por algún otro motivo, el SDK de administrador genera un error. Para obtener una lista completa de los códigos de error, incluidas las descripciones y los pasos de resolución, consulte Errores de API de autenticación de administrador .

Recuperación masiva de datos de usuario

El SDK de administración de Firebase también permite recuperar una lista de usuarios según los identificadores que proporcione. Puede identificar a los usuarios por su ID de usuario, correo electrónico o número de teléfono. Se pueden proporcionar un máximo de 100 identificadores en una sola llamada. Los identificadores pueden contener una combinación de tipos:

Nodo.js

getAuth()
  .getUsers([
    { uid: 'uid1' },
    { email: 'user2@example.com' },
    { phoneNumber: '+15555550003' },
    { providerId: 'google.com', providerUid: 'google_uid4' },
  ])
  .then((getUsersResult) => {
    console.log('Successfully fetched user data:');
    getUsersResult.users.forEach((userRecord) => {
      console.log(userRecord);
    });

    console.log('Unable to find users corresponding to these identifiers:');
    getUsersResult.notFound.forEach((userIdentifier) => {
      console.log(userIdentifier);
    });
  })
  .catch((error) => {
    console.log('Error fetching user data:', error);
  });

Java

GetUsersResult result = FirebaseAuth.getInstance().getUsersAsync(Arrays.asList(
    new UidIdentifier("uid1"),
    new EmailIdentifier("user2@example.com"),
    new PhoneIdentifier("+15555550003"),
    new ProviderIdentifier("google.com", "google_uid4"))).get();

System.out.println("Successfully fetched user data:");
for (UserRecord user : result.getUsers()) {
  System.out.println(user.getUid());
}

System.out.println("Unable to find users corresponding to these identifiers:");
for (UserIdentifier uid : result.getNotFound()) {
  System.out.println(uid);
}

Pitón

from firebase_admin import auth

result = auth.get_users([
    auth.UidIdentifier('uid1'),
    auth.EmailIdentifier('user2@example.com'),
    auth.PhoneIdentifier(+15555550003),
    auth.ProviderIdentifier('google.com', 'google_uid4')
])

print('Successfully fetched user data:')
for user in result.users:
    print(user.uid)

print('Unable to find users corresponding to these identifiers:')
for uid in result.not_found:
    print(uid)

Vamos

getUsersResult, err := client.GetUsers(ctx, []auth.UserIdentifier{
	auth.UIDIdentifier{UID: "uid1"},
	auth.EmailIdentifier{Email: "user@example.com"},
	auth.PhoneIdentifier{PhoneNumber: "+15555551234"},
	auth.ProviderIdentifier{ProviderID: "google.com", ProviderUID: "google_uid1"},
})
if err != nil {
	log.Fatalf("error retriving multiple users: %v\n", err)
}

log.Printf("Successfully fetched user data:")
for _, u := range getUsersResult.Users {
	log.Printf("%v", u)
}

log.Printf("Unable to find users corresponding to these identifiers:")
for _, id := range getUsersResult.NotFound {
	log.Printf("%v", id)
}

C#

GetUsersResult result = await FirebaseAuth.DefaultInstance.GetUsersAsync(
    new List<UserIdentifier>
    {
        new UidIdentifier("uid1"),
        new EmailIdentifier("user2@example.com"),
        new PhoneIdentifier("+15555550003"),
        new ProviderIdentifier("google.com", "google_uid4"),
    });

Console.WriteLine("Successfully fetched user data:");
foreach (UserRecord user in result.Users)
{
    Console.WriteLine($"User: {user.Uid}");
}

Console.WriteLine("Unable to find users corresponding to these identifiers:");
foreach (UserIdentifier uid in result.NotFound)
{
    Console.WriteLine($"{uid}");
}

Este método devuelve una lista del mismo tamaño que la lista de entrada, con cada entrada que contiene el UserRecord correspondiente o un error que indica por qué no se pudo buscar ese identificador. Para obtener una lista completa de los códigos de error, incluidas las descripciones y los pasos de resolución, consulte Errores de API de autenticación de administrador .

crear un usuario

Admin SDK proporciona un método que le permite crear un nuevo usuario de Firebase Authentication. Este método acepta un objeto que contiene la información del perfil para incluir en la cuenta de usuario recién creada:

Nodo.js

getAuth()
  .createUser({
    email: 'user@example.com',
    emailVerified: false,
    phoneNumber: '+11234567890',
    password: 'secretPassword',
    displayName: 'John Doe',
    photoURL: 'http://www.example.com/12345678/photo.png',
    disabled: false,
  })
  .then((userRecord) => {
    // See the UserRecord reference doc for the contents of userRecord.
    console.log('Successfully created new user:', userRecord.uid);
  })
  .catch((error) => {
    console.log('Error creating new user:', error);
  });

Java

CreateRequest request = new CreateRequest()
    .setEmail("user@example.com")
    .setEmailVerified(false)
    .setPassword("secretPassword")
    .setPhoneNumber("+11234567890")
    .setDisplayName("John Doe")
    .setPhotoUrl("http://www.example.com/12345678/photo.png")
    .setDisabled(false);

UserRecord userRecord = FirebaseAuth.getInstance().createUser(request);
System.out.println("Successfully created new user: " + userRecord.getUid());

Pitón

user = auth.create_user(
    email='user@example.com',
    email_verified=False,
    phone_number='+15555550100',
    password='secretPassword',
    display_name='John Doe',
    photo_url='http://www.example.com/12345678/photo.png',
    disabled=False)
print('Sucessfully created new user: {0}'.format(user.uid))

Vamos

params := (&auth.UserToCreate{}).
	Email("user@example.com").
	EmailVerified(false).
	PhoneNumber("+15555550100").
	Password("secretPassword").
	DisplayName("John Doe").
	PhotoURL("http://www.example.com/12345678/photo.png").
	Disabled(false)
u, err := client.CreateUser(ctx, params)
if err != nil {
	log.Fatalf("error creating user: %v\n", err)
}
log.Printf("Successfully created user: %v\n", u)

C#

UserRecordArgs args = new UserRecordArgs()
{
    Email = "user@example.com",
    EmailVerified = false,
    PhoneNumber = "+11234567890",
    Password = "secretPassword",
    DisplayName = "John Doe",
    PhotoUrl = "http://www.example.com/12345678/photo.png",
    Disabled = false,
};
UserRecord userRecord = await FirebaseAuth.DefaultInstance.CreateUserAsync(args);
// See the UserRecord reference doc for the contents of userRecord.
Console.WriteLine($"Successfully created new user: {userRecord.Uid}");

De manera predeterminada, Firebase Authentication generará un uid aleatorio para el nuevo usuario. Si, en cambio, desea especificar su propio uid para el nuevo usuario, puede incluirlo como un argumento pasado al método de creación de usuarios:

Nodo.js

getAuth()
  .createUser({
    uid: 'some-uid',
    email: 'user@example.com',
    phoneNumber: '+11234567890',
  })
  .then((userRecord) => {
    // See the UserRecord reference doc for the contents of userRecord.
    console.log('Successfully created new user:', userRecord.uid);
  })
  .catch((error) => {
    console.log('Error creating new user:', error);
  });

Java

CreateRequest request = new CreateRequest()
    .setUid("some-uid")
    .setEmail("user@example.com")
    .setPhoneNumber("+11234567890");

UserRecord userRecord = FirebaseAuth.getInstance().createUser(request);
System.out.println("Successfully created new user: " + userRecord.getUid());

Pitón

user = auth.create_user(
    uid='some-uid', email='user@example.com', phone_number='+15555550100')
print('Sucessfully created new user: {0}'.format(user.uid))

Vamos

params := (&auth.UserToCreate{}).
	UID(uid).
	Email("user@example.com").
	PhoneNumber("+15555550100")
u, err := client.CreateUser(ctx, params)
if err != nil {
	log.Fatalf("error creating user: %v\n", err)
}
log.Printf("Successfully created user: %v\n", u)

C#

UserRecordArgs args = new UserRecordArgs()
{
    Uid = "some-uid",
    Email = "user@example.com",
    PhoneNumber = "+11234567890",
};
UserRecord userRecord = await FirebaseAuth.DefaultInstance.CreateUserAsync(args);
// See the UserRecord reference doc for the contents of userRecord.
Console.WriteLine($"Successfully created new user: {userRecord.Uid}");

Se puede proporcionar cualquier combinación de las siguientes propiedades:

Tabla 1. Propiedades admitidas por la operación de creación de usuario

Propiedad Escribe Descripción
uid cuerda El uid que se asignará al usuario recién creado. Debe ser una cadena de entre 1 y 128 caracteres, inclusive. Si no se proporciona, se generará automáticamente un uid aleatorio.
email cuerda El correo electrónico principal del usuario. Debe ser una dirección de correo electrónico válida.
emailVerified booleano Si se verifica o no el correo electrónico principal del usuario. Si no se proporciona, el valor predeterminado es false .
phoneNumber cuerda El número de teléfono principal del usuario. Debe ser un número de teléfono válido que cumpla con la especificación E.164.
password cuerda La contraseña sin procesar y sin hash del usuario. Debe tener al menos seis caracteres.
displayName cuerda El nombre para mostrar de los usuarios.
photoURL cuerda URL de la foto del usuario.
disabled booleano Si el usuario está deshabilitado o no. true para discapacitados; false para habilitado. Si no se proporciona, el valor predeterminado es false .

El método de creación de usuarios devuelve un objeto UserRecord para el usuario recién creado.

Si el uid , el correo electrónico o el número de teléfono proporcionados ya están en uso por un usuario existente o el usuario no se puede crear por cualquier otro motivo, el método anterior falla y genera un error. Para obtener una lista completa de los códigos de error, incluidas las descripciones y los pasos de resolución, consulte Errores de API de autenticación de administrador .

Actualizar un usuario

El SDK de administración de Firebase facilita la modificación de los datos de un usuario existente. Debe especificar un uid junto con las propiedades para actualizar para ese usuario:

Nodo.js

getAuth()
  .updateUser(uid, {
    email: 'modifiedUser@example.com',
    phoneNumber: '+11234567890',
    emailVerified: true,
    password: 'newPassword',
    displayName: 'Jane Doe',
    photoURL: 'http://www.example.com/12345678/photo.png',
    disabled: true,
  })
  .then((userRecord) => {
    // See the UserRecord reference doc for the contents of userRecord.
    console.log('Successfully updated user', userRecord.toJSON());
  })
  .catch((error) => {
    console.log('Error updating user:', error);
  });

Java

UpdateRequest request = new UpdateRequest(uid)
    .setEmail("user@example.com")
    .setPhoneNumber("+11234567890")
    .setEmailVerified(true)
    .setPassword("newPassword")
    .setDisplayName("Jane Doe")
    .setPhotoUrl("http://www.example.com/12345678/photo.png")
    .setDisabled(true);

UserRecord userRecord = FirebaseAuth.getInstance().updateUser(request);
System.out.println("Successfully updated user: " + userRecord.getUid());

Pitón

user = auth.update_user(
    uid,
    email='user@example.com',
    phone_number='+15555550100',
    email_verified=True,
    password='newPassword',
    display_name='John Doe',
    photo_url='http://www.example.com/12345678/photo.png',
    disabled=True)
print('Sucessfully updated user: {0}'.format(user.uid))

Vamos

params := (&auth.UserToUpdate{}).
	Email("user@example.com").
	EmailVerified(true).
	PhoneNumber("+15555550100").
	Password("newPassword").
	DisplayName("John Doe").
	PhotoURL("http://www.example.com/12345678/photo.png").
	Disabled(true)
u, err := client.UpdateUser(ctx, uid, params)
if err != nil {
	log.Fatalf("error updating user: %v\n", err)
}
log.Printf("Successfully updated user: %v\n", u)

C#

UserRecordArgs args = new UserRecordArgs()
{
    Uid = uid,
    Email = "modifiedUser@example.com",
    PhoneNumber = "+11234567890",
    EmailVerified = true,
    Password = "newPassword",
    DisplayName = "Jane Doe",
    PhotoUrl = "http://www.example.com/12345678/photo.png",
    Disabled = true,
};
UserRecord userRecord = await FirebaseAuth.DefaultInstance.UpdateUserAsync(args);
// See the UserRecord reference doc for the contents of userRecord.
Console.WriteLine($"Successfully updated user: {userRecord.Uid}");

Se puede proporcionar cualquier combinación de las siguientes propiedades:

Tabla 2. Propiedades admitidas por la operación de actualización de usuario

Propiedad Escribe Descripción
email cuerda El nuevo correo electrónico principal del usuario. Debe ser una dirección de correo electrónico válida.
emailVerified booleano Si se verifica o no el correo electrónico principal del usuario. Si no se proporciona, el valor predeterminado es false .
phoneNumber cuerda El nuevo número de teléfono principal del usuario. Debe ser un número de teléfono válido que cumpla con la especificación E.164. Establézcalo en null para borrar el número de teléfono existente del usuario.
password cuerda La nueva contraseña sin procesar y sin hash del usuario. Debe tener al menos seis caracteres.
displayName cadena | null El nuevo nombre para mostrar de los usuarios. Establézcalo en null para borrar el nombre para mostrar existente del usuario.
photoURL cadena | null La URL de la nueva foto de los usuarios. Establézcalo en null para borrar la URL de la foto existente del usuario. Si no es null , debe ser una URL válida.
disabled booleano Si el usuario está deshabilitado o no. true para discapacitados; false para habilitado.

El método de usuario de actualización devuelve un objeto UserRecord actualizado cuando la actualización se completa correctamente.

Si el uid proporcionado no corresponde a un usuario existente, el correo electrónico o el número de teléfono proporcionados ya están en uso por un usuario existente, o el usuario no se puede actualizar por cualquier otro motivo, el método anterior falla y genera un error. Para obtener una lista completa de los códigos de error, incluidas las descripciones y los pasos de resolución, consulte Errores de API de autenticación de administrador .

Eliminar un usuario

El SDK de administración de Firebase permite eliminar usuarios existentes por su uid :

Nodo.js

getAuth()
  .deleteUser(uid)
  .then(() => {
    console.log('Successfully deleted user');
  })
  .catch((error) => {
    console.log('Error deleting user:', error);
  });

Java

FirebaseAuth.getInstance().deleteUser(uid);
System.out.println("Successfully deleted user.");

Pitón

auth.delete_user(uid)
print('Successfully deleted user')

Vamos

err := client.DeleteUser(ctx, uid)
if err != nil {
	log.Fatalf("error deleting user: %v\n", err)
}
log.Printf("Successfully deleted user: %s\n", uid)

C#

await FirebaseAuth.DefaultInstance.DeleteUserAsync(uid);
Console.WriteLine("Successfully deleted user.");

El método de eliminación de usuario devuelve un resultado vacío cuando la eliminación se completa con éxito.

Si el uid proporcionado no corresponde a un usuario existente o el usuario no se puede eliminar por cualquier otro motivo, el método de eliminación de usuario genera un error. Para obtener una lista completa de los códigos de error, incluidas las descripciones y los pasos de resolución, consulte Errores de API de autenticación de administrador .

Eliminar varios usuarios

El SDK de administración de Firebase también puede eliminar varios usuarios a la vez. Sin embargo, tenga en cuenta que el uso de métodos como deleteUsers(uids) para eliminar varios usuarios a la vez no activará los controladores de eventos onDelete() para Cloud Functions para Firebase. Esto se debe a que la eliminación por lotes no activa un evento de eliminación de usuario en cada usuario. Elimine usuarios de uno en uno si desea que se activen eventos de eliminación de usuarios para cada usuario eliminado.

Nodo.js

getAuth()
  .deleteUsers([uid1, uid2, uid3])
  .then((deleteUsersResult) => {
    console.log(`Successfully deleted ${deleteUsersResult.successCount} users`);
    console.log(`Failed to delete ${deleteUsersResult.failureCount} users`);
    deleteUsersResult.errors.forEach((err) => {
      console.log(err.error.toJSON());
    });
  })
  .catch((error) => {
    console.log('Error deleting users:', error);
  });

Java

DeleteUsersResult result = FirebaseAuth.getInstance().deleteUsersAsync(
    Arrays.asList("uid1", "uid2", "uid3")).get();

System.out.println("Successfully deleted " + result.getSuccessCount() + " users");
System.out.println("Failed to delete " + result.getFailureCount() + " users");
for (ErrorInfo error : result.getErrors()) {
  System.out.println("error #" + error.getIndex() + ", reason: " + error.getReason());
}

Pitón

from firebase_admin import auth

result = auth.delete_users(["uid1", "uid2", "uid3"])

print('Successfully deleted {0} users'.format(result.success_count))
print('Failed to delete {0} users'.format(result.failure_count))
for err in result.errors:
    print('error #{0}, reason: {1}'.format(result.index, result.reason))

Vamos

deleteUsersResult, err := client.DeleteUsers(ctx, []string{"uid1", "uid2", "uid3"})
if err != nil {
	log.Fatalf("error deleting users: %v\n", err)
}

log.Printf("Successfully deleted %d users", deleteUsersResult.SuccessCount)
log.Printf("Failed to delete %d users", deleteUsersResult.FailureCount)
for _, err := range deleteUsersResult.Errors {
	log.Printf("%v", err)
}

C#

DeleteUsersResult result = await FirebaseAuth.DefaultInstance.DeleteUsersAsync(new List<string>
    {
        "uid1",
        "uid2",
        "uid3",
    });

Console.WriteLine($"Successfully deleted {result.SuccessCount} users.");
Console.WriteLine($"Failed to delete {result.FailureCount} users.");

foreach (ErrorInfo err in result.Errors)
{
    Console.WriteLine($"Error #{err.Index}, reason: {err.Reason}");
}

El método de eliminación de usuarios devuelve una lista de fallas para los usuarios que no se pudieron eliminar. Para obtener una lista completa de los códigos de error, incluidas las descripciones y los pasos de resolución, consulte Errores de API de autenticación de administrador .

Listar todos los usuarios

El SDK de Firebase Admin permite recuperar la lista completa de usuarios en lotes:

Nodo.js

const listAllUsers = (nextPageToken) => {
  // List batch of users, 1000 at a time.
  getAuth()
    .listUsers(1000, nextPageToken)
    .then((listUsersResult) => {
      listUsersResult.users.forEach((userRecord) => {
        console.log('user', userRecord.toJSON());
      });
      if (listUsersResult.pageToken) {
        // List next batch of users.
        listAllUsers(listUsersResult.pageToken);
      }
    })
    .catch((error) => {
      console.log('Error listing users:', error);
    });
};
// Start listing users from the beginning, 1000 at a time.
listAllUsers();

Java

// Start listing users from the beginning, 1000 at a time.
ListUsersPage page = FirebaseAuth.getInstance().listUsers(null);
while (page != null) {
  for (ExportedUserRecord user : page.getValues()) {
    System.out.println("User: " + user.getUid());
  }
  page = page.getNextPage();
}

// Iterate through all users. This will still retrieve users in batches,
// buffering no more than 1000 users in memory at a time.
page = FirebaseAuth.getInstance().listUsers(null);
for (ExportedUserRecord user : page.iterateAll()) {
  System.out.println("User: " + user.getUid());
}

Pitón

# Start listing users from the beginning, 1000 at a time.
page = auth.list_users()
while page:
    for user in page.users:
        print('User: ' + user.uid)
    # Get next batch of users.
    page = page.get_next_page()

# Iterate through all users. This will still retrieve users in batches,
# buffering no more than 1000 users in memory at a time.
for user in auth.list_users().iterate_all():
    print('User: ' + user.uid)

Vamos

// Note, behind the scenes, the Users() iterator will retrive 1000 Users at a time through the API
iter := client.Users(ctx, "")
for {
	user, err := iter.Next()
	if err == iterator.Done {
		break
	}
	if err != nil {
		log.Fatalf("error listing users: %s\n", err)
	}
	log.Printf("read user user: %v\n", user)
}

// Iterating by pages 100 users at a time.
// Note that using both the Next() function on an iterator and the NextPage()
// on a Pager wrapping that same iterator will result in an error.
pager := iterator.NewPager(client.Users(ctx, ""), 100, "")
for {
	var users []*auth.ExportedUserRecord
	nextPageToken, err := pager.NextPage(&users)
	if err != nil {
		log.Fatalf("paging error %v\n", err)
	}
	for _, u := range users {
		log.Printf("read user user: %v\n", u)
	}
	if nextPageToken == "" {
		break
	}
}

C#

// Start listing users from the beginning, 1000 at a time.
var pagedEnumerable = FirebaseAuth.DefaultInstance.ListUsersAsync(null);
var responses = pagedEnumerable.AsRawResponses().GetAsyncEnumerator();
while (await responses.MoveNextAsync())
{
    ExportedUserRecords response = responses.Current;
    foreach (ExportedUserRecord user in response.Users)
    {
        Console.WriteLine($"User: {user.Uid}");
    }
}

// Iterate through all users. This will still retrieve users in batches,
// buffering no more than 1000 users in memory at a time.
var enumerator = FirebaseAuth.DefaultInstance.ListUsersAsync(null).GetAsyncEnumerator();
while (await enumerator.MoveNextAsync())
{
    ExportedUserRecord user = enumerator.Current;
    Console.WriteLine($"User: {user.Uid}");
}

Cada lote de resultados contiene una lista de usuarios y el token de página siguiente que se usa para enumerar el siguiente lote de usuarios. Cuando ya se han enumerado todos los usuarios, no se devuelve ningún pageToken de página.

Si no se especifica ningún campo maxResults , se utiliza el valor predeterminado de 1000 usuarios por lote. Este es también el número máximo de usuarios que se permite enumerar a la vez. Cualquier valor mayor que el máximo arrojará un error de argumento. Si no se especifica pageToken , la operación enumerará a los usuarios desde el principio, ordenados por uid .

Para obtener una lista completa de los códigos de error, incluidas las descripciones y los pasos de resolución, consulte Errores de API de autenticación de administrador .

Hashes de contraseña de los usuarios enumerados

Esta API también devuelve el valor de passwordSalt y passwordHash generado por el backend de Firebase Auth para usuarios de contraseñas si la cuenta de usuario/servicio utilizada para generar el token de acceso de OAuth de solicitud tiene el permiso firebaseauth.configs.getHashConfig . De lo contrario, passwordHash y passwordSalt no se establecerán.

Debido a la naturaleza confidencial de los hash de contraseña, la cuenta de servicio del SDK de administración de Firebase no tiene el permiso firebaseauth.configs.getHashConfig de forma predeterminada. No puede agregar un permiso directamente a una cuenta de usuario/servicio, pero puede hacerlo indirectamente mediante la creación de un rol de IAM personalizado .

Para crear el rol de IAM personalizado:

  1. Vaya a la página Roles en IAM y panel de administración en Google Cloud Console.
  2. Seleccione su proyecto del menú desplegable en la parte superior de la página.
  3. Haga clic en CREAR ROL
  4. Haga clic en AGREGAR PERMISOS
  5. Busque el permiso firebaseauth.configs.getHashConfig y seleccione esa casilla de verificación.
  6. Haga clic en AÑADIR
  7. Haga clic en CREAR para terminar de crear el nuevo rol.

Agregue el rol personalizado creado a la cuenta de usuario/servicio en la página de IAM:

  1. En el panel de IAM y administración , seleccione IAM
  2. Seleccione el servicio o la cuenta de usuario de la lista de miembros para editar.
  3. Haga clic en AÑADIR OTRA FUNCIÓN .
  4. Busque el nuevo rol personalizado creado anteriormente.
  5. Haga clic en GUARDAR .