Mira demostraciones sobre cómo compilar y ejecutar apps impulsadas por IA con Firebase en el Demo Day de 2024. Míralo ahora.

Administrar usuarios

El SDK de Firebase Admin proporciona una API para administrar tus usuarios de Firebase Authentication con privilegios elevados. La API de administrador de usuarios te permite completar las siguientes tareas de manera programática desde un entorno de servidor seguro:

Crear usuarios nuevos sin límite de frecuencia ni regulación.
Buscar usuarios según diversos criterios, como correo electrónico, UID o número de teléfono.
Ver todos los usuarios de un proyecto específico en lotes.
Acceder a los metadatos de un usuario, como la fecha de creación de su cuenta y la fecha de acceso más reciente.
Borrar usuarios sin requerir su contraseña actual.
Actualizar las propiedades de un usuario (incluso su contraseña) sin que sea necesario acceder como el usuario.
Verificar correos electrónicos sin realizar el procedimiento normal.
Cambiar el correo electrónico de un usuario sin la necesidad de enviar vínculos para revocar estos cambios.
Crear un usuario nuevo con un número de teléfono sin la necesidad de realizar el flujo de verificación por SMS.
Cambiar el número de teléfono de un usuario sin la necesidad de realizar el flujo de verificación por SMS.
Aprovisionar a los usuarios inhabilitados sin conexión y controlar su posterior habilitación.
Crear consolas de usuario personalizadas para sistemas de administración de usuarios de aplicaciones específicas.

Antes de comenzar

Para usar la API de administración de usuarios que proporciona el SDK de administrador de Firebase, debes tener una cuenta de servicio. Sigue las instrucciones de configuración para obtener más detalles sobre cómo inicializar el SDK de Admin.

Recupera los datos del usuario

El método principal para identificar a un usuario es a través de su uid, un identificador único del usuario. El SDK de Admin proporciona un método que permite recuperar la información de perfil de los usuarios según su uid:

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

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

Python

from firebase_admin import auth

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

Go

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

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 muestra un objeto UserRecord para el usuario que corresponde al uid que se proporcionó al método.

Si el uid proporcionado no pertenece a un usuario existente o no se puede recuperar el usuario por otro motivo, el método mencionado anteriormente arroja un error. Para ver una lista completa de códigos de error, junto con sus descripciones y los pasos para resolverlos, consulta Errores de la API de autenticación de Admin.

En algunos casos, tendrás el correo electrónico de un usuario en vez de su uid. El SDK de Firebase Admin admite la búsqueda de información de los usuarios por correo electrónico:

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

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

Python

from firebase_admin import auth

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

Go

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

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 muestra un objeto UserRecord para el usuario que corresponde al correo electrónico que se proporcionó.

Si el correo electrónico proporcionado no pertenece a un usuario existente o si el usuario no se puede recuperar por otro motivo, el SDK de Admin arroja un error. Para ver una lista completa de los códigos de error, lo que incluye descripciones y pasos para su resolución, consulta Errores de la API de Authentication de Admin.

Advertencia: Para las búsquedas por correo electrónico, solo se puede buscar el correo electrónico principal (nivel superior), no los correos electrónicos específicos de un proveedor. Por ejemplo, si una cuenta de Facebook con un correo electrónico diferente facebookUser@example.com está vinculada a un usuario existente con el correo electrónico user@example.com, la llamada a getUserByEmail("facebookUser@example.com") no mostrará resultados. Sin embargo, se mostrará el usuario esperado si usas getUserByEmail("user@example.com"). En cuanto a la configuración predeterminada "una sola cuenta por correo electrónico", el primer correo electrónico que se usó para acceder se usará como correo principal, a menos que se modifique posteriormente. Si se configura la opción "varias cuentas por correo electrónico", el correo electrónico principal solo se establece cuando se crea un usuario con contraseña, a menos que se actualice manualmente.

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 de los usuarios con un número de teléfono:

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

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

Python

from firebase_admin import auth

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

Go

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

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 muestra un objeto UserRecord para el usuario que corresponde al número de teléfono que se proporcionó.

Si el número de teléfono proporcionado no pertenece a un usuario existente o si el usuario no se puede recuperar por otro motivo, el SDK de Admin arroja un error. Para ver una lista completa de los códigos de error, lo que incluye descripciones y pasos para su resolución, consulta Errores de la API de Authentication de Admin.

Recupera datos del usuario de forma masiva

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

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

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

Python

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)

Go

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 muestra una lista del mismo tamaño que la lista de entrada. Cada elemento de la lista contiene el UserRecord correspondiente o un error que indica por qué no se pudo buscar ese identificador. Para ver una lista completa de los códigos de error, lo que incluye descripciones y pasos para su resolución, consulta Errores de la API de Authentication de Admin.

Crea un usuario

El SDK de Admin proporciona un método que te permite crear un nuevo usuario de Firebase Authentication. Este método acepta un objeto que contiene la información de perfil y la agrega a la cuenta de usuario recién creada:

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

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

Python

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

Go

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

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 forma predeterminada, Firebase Authentication generará un uid aleatorio para el usuario nuevo. Por el contrario, si deseas especificar tu propio uid para el usuario nuevo, puedes incluirlo en el argumento del método de creación de usuarios:

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

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

Python

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

Go

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

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 que admite la operación de creación de usuarios

Propiedad	Tipo	Descripción
`uid`	string	El `uid` que se asignará al usuario recién creado. Debe ser una string que contenga entre 1 y 128 caracteres. Si no se proporciona, se generará automáticamente un `uid` aleatorio. Los elementos `uid` más cortos tienen un mejor rendimiento.
`email`	string	El correo electrónico principal del usuario. Debe ser un correo electrónico válido.
`emailVerified`	booleano	Indica si se verificó el correo electrónico principal del usuario. Si no se proporciona, el valor predeterminado es `false`.
`phoneNumber`	string	El número de teléfono principal del usuario. Debe ser un número de teléfono válido que cumpla con las especificaciones E.164.
`password`	string	La contraseña del usuario, sin encriptación. Debe tener al menos seis caracteres.
`displayName`	string	El nombre visible del usuario.
`photoURL`	string	La URL de la foto del usuario.
`disabled`	booleano	Si el usuario está inhabilitado o no. `true` indica que está inhabilitado; `false` indica que está habilitado. Si no se proporciona, el valor predeterminado es `false`.

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

Si se proporciona un uid, correo electrónico o número de teléfono que corresponde a un usuario existente o no se puede crear el usuario por otro motivo, el método anterior falla y arroja un error. Para ver una lista completa de los códigos de error, lo que incluye descripciones y pasos para su resolución, consulta Errores de la API de Authentication de Admin.

Actualiza un usuario

El SDK de Firebase Admin facilita la modificación de los datos de un usuario existente. Debes especificar un uid junto con las propiedades que deseas actualizar del usuario:

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

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

Python

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

Go

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

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 que admite la operación de actualización de usuarios

Propiedad	Tipo	Descripción
`email`	string	La nueva dirección de correo electrónico principal del usuario. Debe ser un correo electrónico válido.
`emailVerified`	booleano	Indica si se verificó el correo electrónico principal del usuario. Si no se proporciona, el valor predeterminado es `false`.
`phoneNumber`	string	El nuevo número de teléfono principal del usuario. Debe ser un número de teléfono válido que cumpla con las especificaciones E.164. Si su valor es `null`, se borrará el número de teléfono actual del usuario.
`password`	string	La nueva contraseña del usuario, sin encriptación. Debe tener al menos seis caracteres.
`displayName`	string \| `null`	El nuevo nombre visible del usuario. Si su valor es `null`, se borrará el nombre visible actual del usuario.
`photoURL`	string \| `null`	La nueva URL de la foto del usuario. Si su valor es `null`, se borrará la URL actual de la foto del usuario. Si su valor no es `null`, debe proporcionarse una URL válida.
`disabled`	booleano	Si el usuario está inhabilitado o no. `true` indica que está inhabilitado; `false` indica que está habilitado.

El método de actualización de usuarios muestra un objeto UserRecord actualizado cuando la operación se completa de manera correcta.

Si se proporciona un uid que no corresponde a un usuario existente o un correo electrónico o número de teléfono que ya está en uso, o no se puede actualizar el usuario por otro motivo, el método anterior falla y arroja un error. Para ver una lista completa de los códigos de error, lo que incluye descripciones y pasos para su resolución, consulta Errores de la API de Authentication de Admin.

Borra un usuario

El SDK de Firebase Admin permite borrar usuarios existentes según su uid:

Node.js

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

Java

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

Python

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

Go

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

C#

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

El método de eliminación de usuarios muestra un resultado vacío cuando la eliminación se completa de forma correcta.

Si se proporciona un uid que no corresponde a un usuario existente o no se puede borrar el usuario por otro motivo, el método arroja un error. Para ver una lista completa de los códigos de error, lo que incluye descripciones y pasos para su resolución, consulta Errores de la API de Authentication de Admin.

Borra varios usuarios

Con el SDK de Firebase Admin, también puedes borrar varios usuarios a la vez. Sin embargo, ten en cuenta que usar métodos como deleteUsers(uids) para borrar varios usuarios al mismo tiempo no activará controladores de eventos onDelete() en Cloud Functions for Firebase. porque la eliminación por lotes no activa un evento de eliminación de usuarios en cada usuario. Borra usuarios uno a la vez si quieres que se activen los eventos de eliminación para cada uno de ellos.

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

Python

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

Go

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 para borrar usuarios muestra una lista de fallas sobre los usuarios que no se pudieron borrar. Para ver una lista completa de los códigos de error, lo que incluye descripciones y pasos para su resolución, consulta Errores de la API de Authentication de Admin.

Ve una lista de todos los usuarios

El SDK de administrador de Firebase permite ver la lista completa de usuarios en lotes:

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

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

Python

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

Go

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

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 la página siguiente, que se usa para ver el próximo grupo de usuarios. Cuando ya se vieron todos los usuarios, no se muestra ningún pageToken.

Si no se especifica un campo maxResults, de manera predeterminada se muestran 1,000 usuarios por lote. Esta es también la cantidad máxima de usuarios que se pueden ver a la vez. Cualquier valor superior al máximo arrojará un error de argumento. Si no se especifica un pageToken, la operación mostrará una lista de usuarios desde el principio, ordenados por uid.

Para ver una lista completa de los códigos de error, lo que incluye descripciones y pasos para su resolución, consulta Errores de la API de Authentication de Admin.

Hash de contraseñas de la lista de usuarios

Esta API también muestra los hashes de passwordSalt y passwordHash que generó el backend de Firebase Auth para usuarios con contraseña si la cuenta de usuario o servicio utilizada para generar el token de acceso de OAuth de la solicitud tiene el permiso firebaseauth.configs.getHashConfig. De lo contrario, no se establecerán passwordHash ni passwordSalt.

Debido a la naturaleza sensible de los hashes de contraseñas, la cuenta de servicio del SDK de Firebase Admin no tiene el permiso firebaseauth.configs.getHashConfig en la configuración predeterminada. No puedes agregar un permiso directamente a una cuenta de usuario o servicio, pero puedes hacerlo de forma indirecta si creas un rol de IAM personalizado.

Sigue estos pasos para crear la función de IAM personalizada:

Ve a la página Roles en el panel IAM y administración en la consola de Google Cloud.
Selecciona tu proyecto en el menú desplegable de la parte superior de la página.
Haz clic en CREAR ROL.
Haz clic en AGREGAR PERMISOS.
Busca el permiso de firebaseauth.configs.getHashConfig y selecciona esa casilla de verificación.
Haz clic en AGREGAR.
Haz clic en CREAR para terminar de crear el rol nuevo.

Agrega el rol personalizado que se creó a la cuenta de usuario o servicio en la página de IAM:

En el panel IAM y administración, selecciona IAM.
Selecciona la cuenta de usuario o servicio de la lista de miembros para editarla.
Haz clic en AGREGAR OTRA FUNCIÓN.
Busca el nuevo rol personalizado que creaste.
Haz clic en GUARDAR.