Nutzer verwalten

Das Firebase Admin SDK bietet eine API zum Verwalten Ihrer Firebase Authentication-Nutzer mit erhöhten Berechtigungen. Admin-API zur Nutzerverwaltung können Sie die folgenden Aufgaben programmatisch aus einem sichere Serverumgebung:

• Sie können neue Nutzer ohne Drosselung oder Ratenbegrenzung erstellen.
• Nutzer anhand verschiedener Kriterien wie UID, E-Mail-Adresse oder Telefonnummer suchen
• Hiermit werden alle Nutzer eines bestimmten Projekts in Batches aufgelistet.
• Auf Nutzermetadaten zugreifen, z. B. das Erstellungsdatum des Kontos und das Datum der letzten Anmeldung
• Sie können Nutzer löschen, ohne dass ihr bestehendes Passwort erforderlich ist.
• Nutzereigenschaften, einschließlich des Passworts, aktualisieren, ohne sich anmelden zu müssen als Nutzende.
• E-Mails bestätigen, ohne die Out-of-Band-Aktionsabläufe zur Bestätigung von E-Mails durchlaufen zu müssen
• E-Mail-Adresse eines Nutzers ändern, ohne E-Mail-Links zum Widerrufen dieser Änderungen zu senden
• Sie können einen neuen Nutzer mit einer Telefonnummer erstellen, ohne den SMS-Bestätigungsvorgang durchlaufen zu müssen.
• Die Telefonnummer eines Nutzers ändern, ohne die SMS-Bestätigung durchlaufen zu müssen
• Offlinebereitstellung für deaktivierte Nutzer und spätere Steuerung der folgenden Aktionen aktivieren.
• Benutzerdefinierte Nutzerkonsolen erstellen, die auf das Nutzerverwaltungssystem einer bestimmten Anwendung zugeschnitten sind

Hinweis

Wenn Sie die vom Firebase Admin SDK bereitgestellte API zur Nutzerverwaltung verwenden möchten, benötigen Sie ein Dienstkonto. Weitere Informationen zum Initialisieren des Admin SDK finden Sie in der Einrichtungsanleitung.

Nutzerdaten abrufen

Die primäre Methode zur Identifizierung eines Nutzers ist seine uid, eine eindeutige Kennung für für diesen Nutzer. Das Admin SDK bietet eine Methode zum Abrufen des Profils. Informationen zu Nutzern anhand ihrer uid:

getAuth()
  .getUser(uid)
  .then((userRecord) => {
    // See the UserRecord reference doc for the contents of userRecord.
    console.log(`Successfully fetched user data: ${userRecord.toJSON()}`);
  })
  .catch((error) => {
    console.log('Error fetching user data:', error);
  });
manage_users.js

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

from firebase_admin import auth

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

// Get an auth client from the firebase.App
client, err := app.Auth(ctx)
if err != nil {
	log.Fatalf("error getting Auth client: %v\n", err)
}

u, err := client.GetUser(ctx, uid)
if err != nil {
	log.Fatalf("error getting user %s: %v\n", uid, err)
}
log.Printf("Successfully fetched user data: %v\n", u)
auth.go

UserRecord userRecord = await FirebaseAuth.DefaultInstance.GetUserAsync(uid);
// See the UserRecord reference doc for the contents of userRecord.
Console.WriteLine($"Successfully fetched user data: {userRecord.Uid}");

Diese Methode gibt ein UserRecord-Objekt für den Nutzer zurück, das dem uid entspricht, das der Methode übergeben wurde.

Wenn die angegebene uid nicht zu einem vorhandenen Nutzer gehört oder der Nutzer nicht aus einem anderen Grund abgerufen werden, gibt die Methode oben einen Fehler aus. Eine vollständige Liste der Fehlercodes, einschließlich Beschreibungen und Schritten zur Fehlerbehebung, finden Sie unter Admin Auth API-Fehler.

In einigen Fällen sehen Sie die E-Mail-Adresse eines Nutzers anstelle seiner uid. Das Firebase Admin SDK unterstützt das Abrufen von Nutzerinformationen mit einer E-Mail-Adresse:

getAuth()
  .getUserByEmail(email)
  .then((userRecord) => {
    // See the UserRecord reference doc for the contents of userRecord.
    console.log(`Successfully fetched user data: ${userRecord.toJSON()}`);
  })
  .catch((error) => {
    console.log('Error fetching user data:', error);
  });
manage_users.js

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

from firebase_admin import auth

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

u, err := client.GetUserByEmail(ctx, email)
if err != nil {
	log.Fatalf("error getting user by email %s: %v\n", email, err)
}
log.Printf("Successfully fetched user data: %v\n", u)
auth.go

UserRecord userRecord = await FirebaseAuth.DefaultInstance.GetUserByEmailAsync(email);
// See the UserRecord reference doc for the contents of userRecord.
Console.WriteLine($"Successfully fetched user data: {userRecord.Uid}");

Diese Methode gibt ein UserRecord-Objekt für den Nutzer für die angegebene E-Mail-Adresse.

Wenn die angegebene E-Mail-Adresse nicht zu einem vorhandenen Nutzer gehört oder der Nutzer aus einem anderen Grund nicht abgerufen werden kann, gibt das Admin SDK einen Fehler zurück. Eine vollständige Liste der Fehlercodes, einschließlich Beschreibungen und Schritten zur Fehlerbehebung, finden Sie unter Admin Authentication API-Fehler.

In anderen Fällen wird anstelle der uid die Telefonnummer des Nutzers angezeigt. Das Firebase Admin SDK unterstützt das Abrufen von Nutzerinformationen mit einer Telefonnummer:

getAuth()
  .getUserByPhoneNumber(phoneNumber)
  .then((userRecord) => {
    // See the UserRecord reference doc for the contents of userRecord.
    console.log(`Successfully fetched user data:  ${userRecord.toJSON()}`);
  })
  .catch((error) => {
    console.log('Error fetching user data:', error);
  });
manage_users.js

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

from firebase_admin import auth

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

u, err := client.GetUserByPhoneNumber(ctx, phone)
if err != nil {
	log.Fatalf("error getting user by phone %s: %v\n", phone, err)
}
log.Printf("Successfully fetched user data: %v\n", u)
auth.go

UserRecord userRecord = await FirebaseAuth.DefaultInstance.GetUserByPhoneNumberAsync(phoneNumber);
// See the UserRecord reference doc for the contents of userRecord.
Console.WriteLine($"Successfully fetched user data: {userRecord.Uid}");

Diese Methode gibt ein UserRecord-Objekt für den Nutzer zurück, das der angegebenen Telefonnummer entspricht.

Wenn die angegebene Telefonnummer nicht zu einem vorhandenen Nutzer gehört oder der Nutzer aus einem anderen Grund nicht abgerufen werden kann, wirft das Admin SDK einen Fehler. Für eine vollständige Liste der Fehlercodes, einschließlich Beschreibungen und Lösungsschritte finden Sie unter Admin Authentication API-Fehler.

Nutzerdaten gesammelt abrufen

Mit dem Firebase Admin SDK können Sie auch eine Liste mit Nutzern anhand der von Ihnen bereitgestellten Kennzeichnungen abrufen. Sie können Nutzer anhand ihrer Nutzer-ID, E-Mail-Adresse oder Telefonnummer identifizieren. In einem einzelnen Aufruf können maximal 100 IDs bereitgestellt werden. Kennungen können eine Kombination aus Typen enthalten:

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

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

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)

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

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

Diese Methode gibt eine Liste zurück, die dieselbe Größe wie die Eingabeliste hat, mit jedem Eintrag Enthält entweder das entsprechende UserRecord oder einen Fehler, der den Grund angibt diese ID nicht abgerufen werden konnte. Eine vollständige Liste der Fehlercodes, einschließlich Beschreibungen und Schritten zur Fehlerbehebung, finden Sie unter Admin Authentication API-Fehler.

Nutzer erstellen

Das Admin SDK bietet eine Methode, ermöglicht das Erstellen eines neuen Firebase Authentication-Nutzers. Diese Methode akzeptiert ein Objekt mit den Profilinformationen, die in den neu erstellten Nutzerkonto:

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

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

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

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

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

Standardmäßig generiert Firebase Authentication eine zufällige uid für den neuen Nutzer. Wenn Sie möchten stattdessen Ihre eigene uid für den neuen Nutzer angeben, können Sie sie einschließen als Argument, das an die Methode zur Nutzererstellung übergeben wird:

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

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

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

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

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

Sie können eine beliebige Kombination der folgenden Properties angeben:

Tabelle 1. Vom Befehl „create user“ unterstützte Eigenschaften

Die Methode zur Nutzererstellung gibt ein UserRecord-Objekt für den neu erstellter Nutzer.

Wenn die angegebene uid, E-Mail-Adresse oder Telefonnummer bereits von einem vorhandenen oder der Nutzer aus einem anderen Grund nicht erstellt werden kann, schlägt die obige Methode fehl. mit einem Fehler. Eine vollständige Liste der Fehlercodes, einschließlich Beschreibungen und Lösungsschritte finden Sie unter Admin Authentication API Fehler.

Nutzer aktualisieren

Mit dem Firebase Admin SDK können Sie die Daten eines vorhandenen Nutzers ändern. Du brauchst um eine uid zusammen mit den Attributen anzugeben, die für diesen Nutzer aktualisiert werden sollen:

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

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

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

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

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

Folgende Eigenschaften können beliebig kombiniert werden:

Tabelle 2. Vom Nutzeraktualisierungsvorgang unterstützte Eigenschaften

Die Nutzermethode "update" gibt ein aktualisiertes UserRecord-Objekt zurück, wenn die Aktualisierung erfolgreich abgeschlossen.

Wenn die angegebene uid keinem vorhandenen Nutzer entspricht, die angegebene E-Mail-Adresse oder Telefonnummer bereits von einem anderen Nutzer verwendet wird oder der Nutzer aus einem anderen Grund nicht aktualisiert werden kann, schlägt die oben genannte Methode fehl und es wird eine Fehlermeldung angezeigt. Eine vollständige Liste der Fehlercodes, einschließlich Beschreibungen und Schritten zur Fehlerbehebung, finden Sie unter Admin Authentication API-Fehler.

Nutzer löschen

Mit dem Firebase Admin SDK können vorhandene Nutzer über ihre uid gelöscht werden:

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

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

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

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

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

Die Methode zum Löschen des Nutzers gibt ein leeres Ergebnis zurück, wenn der Löschvorgang abgeschlossen ist. erfolgreich war.

Wenn die angegebene uid keinem vorhandenen Nutzer entspricht oder der Nutzer nicht aus einem anderen Grund gelöscht wird, gibt die Methode zum Löschen des Nutzers einen Fehler aus. Für eine vollständige Liste der Fehlercodes, einschließlich Beschreibungen und Lösungsschritte finden Sie unter Admin Authentication API-Fehler.

Mehrere Nutzer löschen

Mit dem Firebase Admin SDK können auch mehrere Nutzer gleichzeitig gelöscht werden. Wenn Sie jedoch Methoden wie deleteUsers(uids) verwenden, um mehrere Nutzer gleichzeitig zu löschen, werden keine onDelete()-Ereignishandler für Cloud Functions for Firebase ausgelöst. Das liegt daran, dass beim Löschen mehrerer Nutzer nicht für jeden Nutzer ein Löschereignis ausgelöst wird. Nutzer einzeln löschen wenn Sie möchten, dass Löschereignisse für jeden gelöschten Nutzer ausgelöst werden.

getAuth()
  .deleteUsers([uid1, uid2, uid3])
  .then((deleteUsersResult) => {
    console.log(`Successfully deleted ${deleteUsersResult.successCount} users`);
    console.log(`Failed to delete ${deleteUsersResult.failureCount} users`);
    deleteUsersResult.errors.forEach((err) => {
      console.log(err.error.toJSON());
    });
  })
  .catch((error) => {
    console.log('Error deleting users:', error);
  });

DeleteUsersResult result = FirebaseAuth.getInstance().deleteUsersAsync(
    Arrays.asList("uid1", "uid2", "uid3")).get();

System.out.println("Successfully deleted " + result.getSuccessCount() + " users");
System.out.println("Failed to delete " + result.getFailureCount() + " users");
for (ErrorInfo error : result.getErrors()) {
  System.out.println("error #" + error.getIndex() + ", reason: " + error.getReason());
}

from firebase_admin import auth

result = auth.delete_users(["uid1", "uid2", "uid3"])

print('Successfully deleted {0} users'.format(result.success_count))
print('Failed to delete {0} users'.format(result.failure_count))
for err in result.errors:
    print('error #{0}, reason: {1}'.format(result.index, result.reason))

deleteUsersResult, err := client.DeleteUsers(ctx, []string{"uid1", "uid2", "uid3"})
if err != nil {
	log.Fatalf("error deleting users: %v\n", err)
}

log.Printf("Successfully deleted %d users", deleteUsersResult.SuccessCount)
log.Printf("Failed to delete %d users", deleteUsersResult.FailureCount)
for _, err := range deleteUsersResult.Errors {
	log.Printf("%v", err)
}

DeleteUsersResult result = await FirebaseAuth.DefaultInstance.DeleteUsersAsync(new List<string>
    {
        "uid1",
        "uid2",
        "uid3",
    });

Console.WriteLine($"Successfully deleted {result.SuccessCount} users.");
Console.WriteLine($"Failed to delete {result.FailureCount} users.");

foreach (ErrorInfo err in result.Errors)
{
    Console.WriteLine($"Error #{err.Index}, reason: {err.Reason}");
}

Die Methode "delete user" gibt die Liste der Fehler für die Nutzer zurück, die nicht gelöscht werden konnten. Eine vollständige Liste der Fehlercodes, einschließlich Beschreibungen und Schritten zur Fehlerbehebung, finden Sie unter Admin Authentication API-Fehler.

Alle Nutzer aufführen

Mit dem Firebase Admin SDK können Sie die gesamte Liste der Nutzer in Batches abrufen:

const listAllUsers = (nextPageToken) => {
  // List batch of users, 1000 at a time.
  getAuth()
    .listUsers(1000, nextPageToken)
    .then((listUsersResult) => {
      listUsersResult.users.forEach((userRecord) => {
        console.log('user', userRecord.toJSON());
      });
      if (listUsersResult.pageToken) {
        // List next batch of users.
        listAllUsers(listUsersResult.pageToken);
      }
    })
    .catch((error) => {
      console.log('Error listing users:', error);
    });
};
// Start listing users from the beginning, 1000 at a time.
listAllUsers();
manage_users.js

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

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

# Start listing users from the beginning, 1000 at a time.
page = auth.list_users()
while page:
    for user in page.users:
        print('User: ' + user.uid)
    # Get next batch of users.
    page = page.get_next_page()

# Iterate through all users. This will still retrieve users in batches,
# buffering no more than 1000 users in memory at a time.
for user in auth.list_users().iterate_all():
    print('User: ' + user.uid)

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

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

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

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

Jeder Batch von Ergebnissen enthält eine Liste von Nutzern sowie ein Token für die nächste Seite, um den nächsten Nutzer-Batch aufzulisten. Wenn bereits alle Nutzer aufgeführt sind, pageToken wird zurückgegeben.

Wenn kein Feld maxResults angegeben ist, wird der Standardwert von 1.000 Nutzern pro Batch verwendet. Dies ist auch die maximale Anzahl der Nutzer, die gleichzeitig aufgelistet werden können. Beliebig größer als der Maximalwert löst einen Argumentfehler aus. Wenn kein pageToken angegeben ist, werden die Nutzer nach uid sortiert und von Beginn an aufgelistet.

Für eine vollständige Liste der Fehlercodes, einschließlich Beschreibungen und Lösungsschritte finden Sie unter Admin Authentication API-Fehler.

Passwort-Hashes der aufgeführten Nutzer

Diese API gibt auch die vom Firebase Auth-Backend gehashten Werte passwordSalt und passwordHash für Nutzer mit Passwort zurück, wenn das Nutzer-/Dienstkonto, das zum Generieren des OAuth-Zugriffstokens verwendet wurde, die Berechtigung firebaseauth.configs.getHashConfig hat. Andernfalls werden passwordHash und passwordSalt nicht festgelegt.

Aufgrund der sensiblen Natur von Passwort-Hashes kann der Firebase Admin SDK-Dienst Konto hat nicht die Berechtigung firebaseauth.configs.getHashConfig von Standardeinstellung. Sie können einem Nutzer-/Dienstkonto nicht direkt eine Berechtigung hinzufügen, indirekt dadurch möglich, Erstellen einer benutzerdefinierten IAM-Rolle

So erstellen Sie die benutzerdefinierte IAM-Rolle:

1. Rufen Sie in der Google Cloud Console im Bereich IAM & Verwaltung die Seite Rollen auf.
2. Wählen Sie das Projekt oben auf der Seite aus der Drop-down-Liste aus.
3. Klicken Sie auf ROLLE ERSTELLEN.
4. Klicken Sie auf BERECHTIGUNGEN HINZUFÜGEN.
5. Suchen Sie nach der Berechtigung firebaseauth.configs.getHashConfig und klicken Sie das Kästchen an.
6. Klicken Sie auf HINZUFÜGEN.
7. Klicken Sie auf ERSTELLEN, um die neue Rolle zu erstellen.

Fügen Sie dem Nutzer-/Dienstkonto auf der IAM-Seite die erstellte benutzerdefinierte Rolle hinzu:

1. Klicken Sie auf der Seite IAM & Admin-, wählen Sie IAM aus.
2. Wählen Sie das Dienst- oder Nutzerkonto aus der Liste der Mitglieder aus, um es zu bearbeiten.
3. Klicken Sie auf WEITERE ROLLE HINZUFÜGEN.
4. Suchen Sie nach der zuvor erstellten neuen benutzerdefinierten Rolle.
5. Klicken Sie auf SPEICHERN.