Administrar usuarios

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 administradores le brinda la capacidad de completar mediante programación las siguientes tareas desde un entorno de servidor seguro:

• Cree nuevos usuarios sin ninguna limitación ni 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 fecha del último inicio de sesión.
• Elimine usuarios sin requerir su contraseña existente.
• Actualice las propiedades del usuario, incluida su contraseña, sin tener que iniciar sesión como usuario.
• Verifique correos electrónicos sin tener que pasar por los flujos de acción fuera de banda para verificar correos electrónicos.
• Cambie el correo electrónico de un usuario sin enviar enlaces de correo electrónico para revocar estos cambios.
• Crea un nuevo usuario con un número de teléfono sin tener que pasar por el flujo de verificación por SMS.
• Cambie el número de teléfono de un usuario sin tener que pasar por el flujo de verificación por SMS.
• Aprovisione 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 gestión de usuarios de una aplicación específica.

Antes de que empieces

Para utilizar 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 administración.

Recuperar datos de usuario

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

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);
  });
manage_users.js

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());

from firebase_admin import auth

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

// 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)
auth.go

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 puede recuperarse por algún otro motivo, el método anterior genera un error. Para obtener una lista completa de códigos de error, incluidas descripciones y pasos de resolución, consulte Errores de 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 Firebase Admin admite la búsqueda de información del usuario con un correo electrónico:

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);
  });
manage_users.js

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());

from firebase_admin import auth

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

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)
auth.go

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 no se puede recuperar al usuario por algún otro motivo, el SDK de administración genera un error. Para obtener una lista completa de códigos de error, incluidas descripciones y pasos de resolución, consulte Errores de API de autenticación de administrador .

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

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);
  });
manage_users.js

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());

from firebase_admin import auth

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

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)
auth.go

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 no se puede recuperar al usuario por algún otro motivo, el SDK de administración genera un error. Para obtener una lista completa de códigos de error, incluidas descripciones y pasos de resolución, consulte Errores de API de autenticación de administrador .

Recuperar datos de usuario de forma masiva

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

getAuth()
  .getUsers([
    { uid: 'uid1' },
    { email: '[email protected]' },
    { 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);
  });
manage_users.js

GetUsersResult result = FirebaseAuth.getInstance().getUsersAsync(Arrays.asList(
    new UidIdentifier("uid1"),
    new EmailIdentifier("[email protected]"),
    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);
}

from firebase_admin import auth

result = auth.get_users([
    auth.UidIdentifier('uid1'),
    auth.EmailIdentifier('[email protected]'),
    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)

getUsersResult, err := client.GetUsers(ctx, []auth.UserIdentifier{
	auth.UIDIdentifier{UID: "uid1"},
	auth.EmailIdentifier{Email: "[email protected]"},
	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)
}

GetUsersResult result = await FirebaseAuth.DefaultInstance.GetUsersAsync(
    new List<UserIdentifier>
    {
        new UidIdentifier("uid1"),
        new EmailIdentifier("[email protected]"),
        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, y cada entrada contiene el UserRecord correspondiente o un error que indica por qué no se pudo buscar ese identificador. Para obtener una lista completa de códigos de error, incluidas descripciones y pasos de resolución, consulte Errores de API de autenticación de administrador .

Crear un usuario

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

getAuth()
  .createUser({
    email: '[email protected]',
    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);
  });
manage_users.js

CreateRequest request = new CreateRequest()
    .setEmail("[email protected]")
    .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());

user = auth.create_user(
    email='[email protected]',
    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))

params := (&auth.UserToCreate{}).
	Email("[email protected]").
	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)
auth.go

UserRecordArgs args = new UserRecordArgs()
{
    Email = "[email protected]",
    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 forma 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 del usuario:

getAuth()
  .createUser({
    uid: 'some-uid',
    email: '[email protected]',
    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);
  });
manage_users.js

CreateRequest request = new CreateRequest()
    .setUid("some-uid")
    .setEmail("[email protected]")
    .setPhoneNumber("+11234567890");

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

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

params := (&auth.UserToCreate{}).
	UID(uid).
	Email("[email protected]").
	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)
auth.go

UserRecordArgs args = new UserRecordArgs()
{
    Uid = "some-uid",
    Email = "[email protected]",
    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

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 con un error. Para obtener una lista completa de códigos de error, incluidas descripciones y pasos de resolución, consulte Errores de API de autenticación de administrador .

Actualizar un usuario

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

getAuth()
  .updateUser(uid, {
    email: '[email protected]',
    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);
  });
manage_users.js

UpdateRequest request = new UpdateRequest(uid)
    .setEmail("[email protected]")
    .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());

user = auth.update_user(
    uid,
    email='[email protected]',
    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))

params := (&auth.UserToUpdate{}).
	Email("[email protected]").
	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)
auth.go

UserRecordArgs args = new UserRecordArgs()
{
    Uid = uid,
    Email = "[email protected]",
    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

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 puede actualizarse por cualquier otro motivo, el método anterior falla con un error. Para obtener una lista completa de códigos de error, incluidas descripciones y pasos de resolución, consulte Errores de API de autenticación de administrador .

Eliminar un usuario

El SDK de Firebase Admin permite eliminar usuarios existentes por su uid :

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

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

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

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

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 correctamente.

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

Eliminar varios usuarios

El SDK de Firebase Admin 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 desencadena un evento de eliminación de usuarios en cada usuario. Elimine usuarios uno a la vez si desea que se activen eventos de eliminación de usuarios para cada usuario eliminado.

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);
  });

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());
}

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))

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)
}

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 errores de los usuarios que no se pudieron eliminar. Para obtener una lista completa de códigos de error, incluidas descripciones y 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:

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();
manage_users.js

// 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());
}

# 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)

// 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
	}
}
auth.go

// 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 la página siguiente que se utiliza para enumerar el siguiente lote de usuarios. Cuando ya se han incluido todos los usuarios, no se devuelve ningún pageToken .

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

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

Hashes de contraseña de los usuarios listados

Esta API también devuelve passwordSalt y passwordHash codificados 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, no se establecerán passwordHash y passwordSalt .

Debido a la naturaleza confidencial de los hash de contraseña, la cuenta de servicio Firebase Admin SDK 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 creando una función de IAM personalizada .

Para crear el rol de IAM personalizado:

1. Vaya a la página Roles en IAM y panel de administración en la consola de Google Cloud.
2. Seleccione su proyecto en el menú desplegable en la parte superior de la página.
3. Haga clic en CREAR PAPEL
4. Haga clic en AGREGAR PERMISOS
5. Busque el permiso firebaseauth.configs.getHashConfig y seleccione esa casilla de verificación.
6. Haga clic en AGREGAR
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 IAM:

1. En el panel de administración e IAM , seleccione IAM
2. Seleccione el servicio o 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. Clic en Guardar .