Ir a la consola

Administra usuarios

El SDK de Firebase Admin proporciona una API para administrar los usuarios de Firebase Authentication con privilegios elevados. La API de administración 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 nuevo usuario 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 Firebase Admin, debes tener una cuenta de servicio. Sigue las instrucciones de configuración para obtener más información 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

admin.auth().getUser(uid)
  .then(function(userRecord) {
    // See the UserRecord reference doc for the contents of userRecord.
    console.log('Successfully fetched user data:', userRecord.toJSON());
  })
  .catch(function(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());

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)

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

admin.auth().getUserByEmail(email)
  .then(function(userRecord) {
    // See the UserRecord reference doc for the contents of userRecord.
    console.log('Successfully fetched user data:', userRecord.toJSON());
  })
  .catch(function(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());

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)

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 corresponde a un usuario existente o no se puede recuperar el usuario por otro motivo, el SDK de Admin 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 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

admin.auth().getUserByPhoneNumber(phoneNumber)
  .then(function(userRecord) {
    // See the UserRecord reference doc for the contents of userRecord.
    console.log('Successfully fetched user data:', userRecord.toJSON());
  })
  .catch(function(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());

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)

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 corresponde a un usuario existente o no se puede recuperar el usuario por otro motivo, el SDK de Admin 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.

Crea un usuario

El SDK de Admin proporciona un método que te permite crear un nuevo perfil 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

admin.auth().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(function(userRecord) {
    // See the UserRecord reference doc for the contents of userRecord.
    console.log('Successfully created new user:', userRecord.uid);
  })
  .catch(function(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());

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)

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

Según la configuración 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

admin.auth().createUser({
  uid: 'some-uid',
  email: 'user@example.com',
  phoneNumber: '+11234567890'
})
  .then(function(userRecord) {
    // See the UserRecord reference doc for the contents of userRecord.
    console.log('Successfully created new user:', userRecord.uid);
  })
  .catch(function(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());

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)

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.
email string El correo electrónico principal del usuario. Debe ser una dirección de correo electrónico válida.
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 códigos de error, junto con sus descripciones y los pasos para resolverlos, consulta Errores de la API de autenticación 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

admin.auth().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(function(userRecord) {
    // See the UserRecord reference doc for the contents of userRecord.
    console.log('Successfully updated user', userRecord.toJSON());
  })
  .catch(function(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());

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)

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 una dirección de correo electrónico válida.
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 , 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 códigos de error, junto con sus descripciones y los pasos para resolverlos, consulta Errores de la API de autenticación de Admin.

Borra un usuario

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

Node.js

admin.auth().deleteUser(uid)
  .then(function() {
    console.log('Successfully deleted user');
  })
  .catch(function(error) {
    console.log('Error deleting user:', error);
  });

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)

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 operació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 códigos de error, junto con sus descripciones y los pasos para resolverlos, consulta Errores de la API de autenticación de Admin.

Ve una lista de todos los usuarios

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

Node.js

function listAllUsers(nextPageToken) {
  // List batch of users, 1000 at a time.
  admin.auth().listUsers(1000, nextPageToken)
    .then(function(listUsersResult) {
      listUsersResult.users.forEach(function(userRecord) {
        console.log('user', userRecord.toJSON());
      });
      if (listUsersResult.pageToken) {
        // List next batch of users.
        listAllUsers(listUsersResult.pageToken);
      }
    })
    .catch(function(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());
}

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

C#

// Start listing users from the beginning, 1000 at a time.
var pagedEnumerable = FirebaseAuth.DefaultInstance.ListUsersAsync(null);
var responses = pagedEnumerable.AsRawResponses().GetEnumerator();
while (await responses.MoveNext())
{
    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).GetEnumerator();
while (await enumerator.MoveNext())
{
    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 siguiente 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 códigos de error, junto con sus descripciones y los pasos para resolverlos, consulta Errores de la API de autenticación 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 una función de IAM personalizada.

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

  1. Ve a la página Funciones del panel IAM y administración de GCP Console.
  2. Selecciona tu proyecto en el menú desplegable de la parte superior de la página.
  3. Haz clic en CREAR FUNCIÓN.
  4. Haz clic en AGREGAR PERMISOS.
  5. Busca el permiso de firebaseauth.configs.getHashConfig y selecciona esa casilla de verificación.
  6. Haz clic en AGREGAR.
  7. Haz clic en CREAR para terminar de crear la función nueva.

Agrega la función personalizada creada a la cuenta de usuario o servicio en la página de IAM:

  1. En el panel IAM y administración, selecciona IAM.
  2. Selecciona la cuenta de usuario o servicio de la lista de miembros para editarla.
  3. Haz clic en AGREGAR OTRA FUNCIÓN.
  4. Busca la nueva función personalizada que creaste.
  5. Haz clic en GUARDAR.