获取我们在 Firebase 峰会上发布的所有信息,了解 Firebase 可如何帮助您加快应用开发速度并满怀信心地运行应用。了解详情

Gerenciar usuários

O SDK Admin do Firebase fornece uma API para gerenciar seus usuários do Firebase Authentication com privilégios elevados. A API de gerenciamento de usuários administrativos oferece a capacidade de concluir programaticamente as seguintes tarefas em um ambiente de servidor seguro:

  • Crie novos usuários sem qualquer limitação ou limitação de taxa.
  • Procure usuários por diferentes critérios, como uid, e-mail ou número de telefone.
  • Liste todos os usuários de um projeto especificado em lotes.
  • Acesse os metadados do usuário, incluindo a data de criação da conta e a data do último login.
  • Exclua usuários sem exigir a senha existente.
  • Atualize as propriedades do usuário - incluindo sua senha - sem precisar entrar como usuário.
  • Verifique e-mails sem ter que passar pelos fluxos de ação fora de banda para verificar e-mails.
  • Altere o e-mail de um usuário sem enviar links de e-mail para revogar essas alterações.
  • Crie um novo usuário com um número de telefone sem precisar passar pelo fluxo de verificação por SMS.
  • Altere o número de telefone de um usuário sem precisar passar pelo fluxo de verificação por SMS.
  • Aprovisionar usuários offline em um estado desabilitado e depois controlar quando habilitá-los.
  • Crie consoles de usuário personalizados adaptados ao sistema de gerenciamento de usuários de um aplicativo específico.

Antes de você começar

Para usar a API de gerenciamento de usuários fornecida pelo SDK Admin do Firebase, você precisa ter uma conta de serviço. Siga as instruções de configuração para obter mais informações sobre como inicializar o SDK Admin.

Recuperar dados do usuário

A principal maneira de identificar um usuário é pelo uid , um identificador exclusivo para esse usuário. O SDK Admin fornece um método que permite buscar as informações de perfil dos usuários pelo 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);
  });

Java

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

Pitão

from firebase_admin import auth

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

Vai

// 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 retorna um objeto UserRecord para o usuário correspondente ao uid fornecido ao método.

Se o uid fornecido não pertencer a um usuário existente ou o usuário não puder ser buscado por qualquer outro motivo, o método acima gerará um erro. Para obter uma lista completa de códigos de erro, incluindo descrições e etapas de resolução, consulte Erros da API de autenticação de administrador .

Em alguns casos, você terá o e-mail de um usuário em vez de seu uid . O SDK Admin do Firebase é compatível com a pesquisa de informações do usuário com um e-mail:

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

Java

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

Pitão

from firebase_admin import auth

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

Vai

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 retorna um objeto UserRecord para o usuário correspondente ao email fornecido.

Se o e-mail fornecido não pertencer a um usuário existente ou o usuário não puder ser buscado por qualquer outro motivo, o SDK Admin gerará um erro. Para obter uma lista completa de códigos de erro, incluindo descrições e etapas de resolução, consulte Erros da API de autenticação de administrador .

Em outros casos, você terá o número de telefone de um usuário em vez de seu uid . O SDK Admin do Firebase é compatível com a pesquisa de informações do usuário com um número de telefone:

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

Java

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

Pitão

from firebase_admin import auth

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

Vai

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 retorna um objeto UserRecord para o usuário correspondente ao número de telefone fornecido.

Se o número de telefone fornecido não pertencer a um usuário existente ou o usuário não puder ser buscado por qualquer outro motivo, o SDK Admin gerará um erro. Para obter uma lista completa de códigos de erro, incluindo descrições e etapas de resolução, consulte Erros da API de autenticação de administrador .

Recuperar dados do usuário em massa

O SDK Admin do Firebase também permite recuperar uma lista de usuários com base nos identificadores que você fornece. Você pode identificar usuários por seu ID de usuário, e-mail ou número de telefone. Um máximo de 100 identificadores podem ser fornecidos em uma única chamada. Os identificadores podem conter uma combinação 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);
  });

Java

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

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

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

Pitão

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)

Vai

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

Esse método retorna uma lista do mesmo tamanho da lista de entrada, com cada entrada contendo o UserRecord correspondente ou um erro indicando por que esse identificador não pôde ser pesquisado. Para obter uma lista completa de códigos de erro, incluindo descrições e etapas de resolução, consulte Erros da API de autenticação de administrador .

Criar um usuário

O SDK Admin fornece um método que permite criar um novo usuário do Firebase Authentication. Este método aceita um objeto contendo as informações do perfil para incluir na conta de usuário recém-criada:

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

Java

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

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

Pitão

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

Vai

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

Por padrão, o Firebase Authentication gerará um uid aleatório para o novo usuário. Se você quiser especificar seu próprio uid para o novo usuário, você pode incluí-lo como um argumento passado para o método de criação do usuário:

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

Java

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

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

Pitão

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

Vai

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

Qualquer combinação das seguintes propriedades pode ser fornecida:

Tabela 1. Propriedades suportadas pela operação criar usuário

Propriedade Modelo Descrição
uid corda O uid a ser atribuído ao usuário recém-criado. Deve ser uma string entre 1 e 128 caracteres, inclusive. Se não for fornecido, um uid aleatório será gerado automaticamente.
email corda O e-mail principal do usuário. Deve ser um endereço de e-mail válido.
emailVerified boleano Se o e-mail principal do usuário é verificado ou não. Se não for fornecido, o padrão será false .
phoneNumber corda O número de telefone principal do usuário. Deve ser um número de telefone compatível com a especificação E.164 válido.
password corda A senha bruta e sem hash do usuário. Deve ter pelo menos seis caracteres.
displayName corda O nome de exibição dos usuários.
photoURL corda URL da foto do usuário.
disabled boleano Se o usuário está ou não desabilitado. true para deficientes; false para habilitado. Se não for fornecido, o padrão será false .

O método de criação de usuário retorna um objeto UserRecord para o usuário recém-criado.

Se o uid , e-mail ou número de telefone fornecido já estiver em uso por um usuário existente ou o usuário não puder ser criado por qualquer outro motivo, o método acima falhará com um erro. Para obter uma lista completa de códigos de erro, incluindo descrições e etapas de resolução, consulte Erros da API de autenticação de administrador .

Atualizar um usuário

O SDK Admin do Firebase facilita a modificação dos dados de um usuário existente. Você precisa especificar um uid junto com as propriedades a serem atualizadas para esse usuário:

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

Java

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

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

Pitão

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

Vai

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

Qualquer combinação das seguintes propriedades pode ser fornecida:

Tabela 2. Propriedades suportadas pela operação de atualização do usuário

Propriedade Modelo Descrição
email corda O novo e-mail principal do usuário. Deve ser um endereço de e-mail válido.
emailVerified boleano Se o e-mail principal do usuário é verificado ou não. Se não for fornecido, o padrão será false .
phoneNumber corda O novo número de telefone principal do usuário. Deve ser um número de telefone compatível com a especificação E.164 válido. Defina como null para limpar o número de telefone existente do usuário.
password corda A nova senha bruta e sem hash do usuário. Deve ter pelo menos seis caracteres.
displayName seqüência | null O novo nome de exibição dos usuários. Defina como null para limpar o nome de exibição existente do usuário.
photoURL seqüência | null O novo URL da foto dos usuários. Defina como null para limpar o URL da foto existente do usuário. Se não null , deve ser um URL válido.
disabled boleano Se o usuário está ou não desabilitado. true para deficientes; false para habilitado.

O método de atualização do usuário retorna um objeto UserRecord atualizado quando a atualização é concluída com êxito.

Se o uid fornecido não corresponder a um usuário existente, o e-mail ou número de telefone fornecido já estiver em uso por um usuário existente ou o usuário não puder ser atualizado por qualquer outro motivo, o método acima falhará com um erro. Para obter uma lista completa de códigos de erro, incluindo descrições e etapas de resolução, consulte Erros da API de autenticação de administrador .

Excluir um usuário

O SDK Admin do Firebase permite excluir usuários existentes pelo uid :

Node.js

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

Java

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

Pitão

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

Vai

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

O método delete user retorna um resultado vazio quando a exclusão é concluída com sucesso.

Se o uid fornecido não corresponder a um usuário existente ou o usuário não puder ser excluído por qualquer outro motivo, o método delete user gerará um erro. Para obter uma lista completa de códigos de erro, incluindo descrições e etapas de resolução, consulte Erros da API de autenticação de administrador .

Excluir vários usuários

O SDK Admin do Firebase também pode excluir vários usuários de uma vez. No entanto, o uso de métodos como deleteUsers(uids) para excluir vários usuários de uma vez não acionará manipuladores de eventos onDelete() para o Cloud Functions para Firebase. Isso ocorre porque a exclusão em lote não aciona um evento de exclusão de usuário em cada usuário. Exclua os usuários um de cada vez se desejar que os eventos de exclusão de usuário sejam acionados para cada usuário excluído.

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

Pitão

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

Vai

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

O método delete users retorna uma lista de falhas para os usuários que não puderam ser excluídos. Para obter uma lista completa de códigos de erro, incluindo descrições e etapas de resolução, consulte Erros da API de autenticação de administrador .

Listar todos os usuários

O SDK Admin do Firebase permite recuperar toda a lista de usuários em 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();

Java

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

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

Pitão

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

Vai

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

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

C#

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

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

Cada lote de resultados contém uma lista de usuários e o token de próxima página usado para listar o próximo lote de usuários. Quando todos os usuários já foram listados, nenhum pageToken é retornado.

Se nenhum campo maxResults for especificado, o padrão de 1.000 usuários por lote será usado. Este também é o número máximo de usuários que podem ser listados por vez. Qualquer valor maior que o máximo lançará um erro de argumento. Se nenhum pageToken for especificado, a operação listará os usuários desde o início, ordenados por uid .

Para obter uma lista completa de códigos de erro, incluindo descrições e etapas de resolução, consulte Erros da API de autenticação de administrador .

Hashes de senha de usuários listados

Essa API também retorna o passwordSalt e o passwordHash com hash do Firebase Auth back-end para usuários de senha se a conta de usuário/serviço usada para gerar o token de acesso OAuth de solicitação tiver a permissão firebaseauth.configs.getHashConfig . Caso contrário, passwordHash e passwordSalt não serão definidos.

Devido à natureza confidencial dos hashes de senha, a conta de serviço do SDK Admin do Firebase não tem a permissão firebaseauth.configs.getHashConfig por padrão. Você não pode adicionar uma permissão diretamente a uma conta de usuário/serviço, mas pode fazê-lo indiretamente criando uma função personalizada do IAM .

Para criar a função personalizada do IAM:

  1. Acesse a página Papéis no IAM e no painel de administração no Console do Google Cloud.
  2. Selecione seu projeto no menu suspenso na parte superior da página.
  3. Clique em CRIAR PAPEL
  4. Clique em ADICIONAR PERMISSÕES
  5. Pesquise a permissão firebaseauth.configs.getHashConfig e marque essa caixa de seleção.
  6. Clique em ADICIONAR
  7. Clique em CRIAR para concluir a criação da nova função.

Adicione a função personalizada criada à conta de usuário/serviço na página do IAM:

  1. No painel IAM e administrador , selecione IAM
  2. Selecione o serviço ou conta de usuário na lista de membros para edição.
  3. Clique em ADICIONAR OUTRA FUNÇÃO .
  4. Procure a nova função personalizada criada anteriormente.
  5. Clique em SALVAR .