Cómo administrar usuarios

El SDK de administrador de Firebase 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ímites de velocidad 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 especificas

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

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 corresponde a un usuario existente o si el usuario no se puede recuperar por algún motivo, el método anterior muestra un error. Para ver una lista completa de códigos de error, incluida la descripción y los pasos para resolverlos, consulta Errores de la API de Auth de Admin.

En algunos casos, tendrás el correo electrónico de un usuario en vez de su uid. El SDK de administrador de Firebase admite la búsqueda de información de los usuarios con un 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)

Este método muestra un objeto UserRecord para el usuario que corresponde al correo electrónico proporcionado.

Si el correo electrónico proporcionado no corresponde 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 códigos de error, junto con sus descripciones y los pasos para resolverlos, consulta Errores de la API de Authentication de Admin.

En otros casos, tendrás el número de teléfono de un usuario en lugar de su uid . El SDK de administrador de Firebase 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)

Este método muestra un objeto UserRecord para el usuario que corresponde al número de teléfono proporcionado.

Si el número de teléfono proporcionado no corresponde 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 códigos de error, junto con sus descripciones y los pasos para resolverlos, 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 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)

De manera predeterminada, Firebase Authentication generará un uid aleatorio para el nuevo usuario. Por el contrario, si deseas especificar tu propio uid para el usuario nuevo, puedes incluirlo en el argumento que se le pasa al método de creación del usuario:

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)

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 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á habilitado 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 da como resultado un objeto UserRecord para el usuario recién creado.

Si un usuario existente ya usa el uid o el número de teléfono que se proporciona o el usuario no se puede crear por algún 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 Authentication de Admin.

Actualiza un usuario

El SDK de administrador de Firebase 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)

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 ser una URL válida.
disabled booleano Si el usuario está habilitado o no. true indica que está inhabilitado; false indica que está habilitado.

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

Si el uid proporcionado no corresponde a un usuario existente, un usuario existente ya usa el correo electrónico o el número de teléfono proporcionado o el usuario no se puede actualizar por algún 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 Authentication de Admin.

Borra un usuario

El SDK de administrador de Firebase 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)

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

Si el uid proporcionado no corresponde a un usuario existente o el usuario no se puede borrar por algún 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 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

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

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 recibe un pageToken. Esta API también devuelve los hashes de passwordSalt y passwordHash generados por el backend de Firebase Auth si el usuario es un usuario de contraseña.

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 hora de creación.

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 Authentication de Admin.

Enviar comentarios sobre...

Si necesitas ayuda, visita nuestra página de asistencia.