Nutzer verwalten

Das Firebase Admin SDK bietet eine API zum Verwalten Ihrer Firebase Authentication-Nutzer mit erhöhten Berechtigungen. Mit der Admin User Management API können Sie die folgenden Aufgaben programmatisch über eine sichere Serverumgebung ausführen:

  • Neue Nutzer ohne Drosselung oder Ratenbegrenzung erstellen
  • Sie können Nutzer anhand verschiedener Kriterien wie UID, E-Mail-Adresse oder Telefonnummer suchen.
  • Alle Nutzer eines angegebenen Projekts in Batches auflisten.
  • Auf Nutzermetadaten zugreifen, einschließlich des Datums der Kontoerstellung und des Datums der letzten Anmeldung.
  • Nutzer löschen, ohne dass ihr vorhandenes Passwort erforderlich ist
  • Nutzereigenschaften, einschließlich des Passworts, aktualisieren, ohne sich als Nutzer anmelden zu müssen.
  • E‑Mail-Adressen bestätigen, ohne die Out-of-Band-Aktionsabläufe für die Bestätigung von E‑Mail-Adressen durchlaufen zu müssen.
  • Die E‑Mail-Adresse eines Nutzers ändern, ohne E‑Mail-Links zum Widerrufen dieser Änderungen zu senden.
  • Einen neuen Nutzer mit einer Telefonnummer erstellen, ohne den SMS-Bestätigungsprozess durchlaufen zu müssen.
  • Die Telefonnummer eines Nutzers ändern, ohne die SMS-Bestätigung durchlaufen zu müssen.
  • Nutzer offline im deaktivierten Zustand bereitstellen und später festlegen, wann sie aktiviert werden sollen.
  • Erstellen Sie benutzerdefinierte Nutzerkonsolen, 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. Folgen Sie der Einrichtungsanleitung, um weitere Informationen zum Initialisieren des Admin SDK zu erhalten.

Nutzerdaten abrufen

Nutzer werden hauptsächlich anhand ihrer uid identifiziert, einer eindeutigen ID für diesen Nutzer. Das Admin SDK bietet eine Methode, mit der die Profilinformationen von Nutzern anhand ihrer uid abgerufen werden können:

Node.js

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

Java

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

Python

from firebase_admin import auth

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

Go

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

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

C#

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

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

Wenn die angegebene uid nicht zu einem vorhandenen Nutzer gehört oder der Nutzer aus einem anderen Grund nicht abgerufen werden kann, wird durch die oben genannte Methode ein Fehler ausgegeben. Eine vollständige Liste der Fehlercodes mit Beschreibungen und Schritten zur Fehlerbehebung finden Sie unter Admin Auth API Errors.

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

Node.js

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

Java

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

Python

from firebase_admin import auth

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

Go

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

C#

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

Diese Methode gibt ein UserRecord-Objekt für den Nutzer zurück, der der angegebenen E-Mail-Adresse entspricht.

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 aus. Eine vollständige Liste der Fehlercodes mit Beschreibungen und Schritten zur Fehlerbehebung finden Sie unter Admin Authentication API-Fehler.

In anderen Fällen haben Sie die Telefonnummer eines Nutzers anstelle seiner uid. Das Firebase Admin SDK unterstützt das Suchen von Nutzerinformationen anhand einer Telefonnummer:

Node.js

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

Java

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

Python

from firebase_admin import auth

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

Go

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

C#

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

Diese Methode gibt ein UserRecord-Objekt für den Nutzer zurück, der 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, gibt das Admin SDK einen Fehler aus. Eine vollständige Liste der Fehlercodes mit Beschreibungen und Schritten zur Fehlerbehebung 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 Kennungen bereitgestellt werden. Kennungen können eine Kombination aus Typen enthalten:

Node.js

getAuth()
  .getUsers([
    { uid: 'uid1' },
    { email: 'user2@example.com' },
    { phoneNumber: '+15555550003' },
    { providerId: 'google.com', providerUid: 'google_uid4' },
  ])
  .then((getUsersResult) => {
    console.log('Successfully fetched user data:');
    getUsersResult.users.forEach((userRecord) => {
      console.log(userRecord);
    });

    console.log('Unable to find users corresponding to these identifiers:');
    getUsersResult.notFound.forEach((userIdentifier) => {
      console.log(userIdentifier);
    });
  })
  .catch((error) => {
    console.log('Error fetching user data:', error);
  });
manage_users.js

Java

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

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

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

Python

from firebase_admin import auth

result = auth.get_users([
    auth.UidIdentifier('uid1'),
    auth.EmailIdentifier('user2@example.com'),
    auth.PhoneIdentifier(+15555550003),
    auth.ProviderIdentifier('google.com', 'google_uid4')
])

print('Successfully fetched user data:')
for user in result.users:
    print(user.uid)

print('Unable to find users corresponding to these identifiers:')
for uid in result.not_found:
    print(uid)

Go

getUsersResult, err := client.GetUsers(ctx, []auth.UserIdentifier{
	auth.UIDIdentifier{UID: "uid1"},
	auth.EmailIdentifier{Email: "user@example.com"},
	auth.PhoneIdentifier{PhoneNumber: "+15555551234"},
	auth.ProviderIdentifier{ProviderID: "google.com", ProviderUID: "google_uid1"},
})
if err != nil {
	log.Fatalf("error retriving multiple users: %v\n", err)
}

log.Printf("Successfully fetched user data:")
for _, u := range getUsersResult.Users {
	log.Printf("%v", u)
}

log.Printf("Unable to find users corresponding to these identifiers:")
for _, id := range getUsersResult.NotFound {
	log.Printf("%v", id)
}

C#

GetUsersResult result = await FirebaseAuth.DefaultInstance.GetUsersAsync(
    new List<UserIdentifier>
    {
        new UidIdentifier("uid1"),
        new EmailIdentifier("user2@example.com"),
        new PhoneIdentifier("+15555550003"),
        new ProviderIdentifier("google.com", "google_uid4"),
    });

Console.WriteLine("Successfully fetched user data:");
foreach (UserRecord user in result.Users)
{
    Console.WriteLine($"User: {user.Uid}");
}

Console.WriteLine("Unable to find users corresponding to these identifiers:");
foreach (UserIdentifier uid in result.NotFound)
{
    Console.WriteLine($"{uid}");
}

Diese Methode gibt eine Liste zurück, die die gleiche Größe wie die Eingabeliste hat. Jeder Eintrag enthält entweder den entsprechenden UserRecord oder einen Fehler, der angibt, warum diese ID nicht nachgeschlagen werden konnte. Eine vollständige Liste der Fehlercodes mit Beschreibungen und Schritten zur Fehlerbehebung finden Sie unter Admin Authentication API-Fehler.

Nutzer erstellen

Das Admin SDK bietet eine Methode, mit der Sie einen neuen Firebase Authentication-Nutzer erstellen können. Diese Methode akzeptiert ein Objekt mit den Profilinformationen, die in das neu erstellte Nutzerkonto aufgenommen werden sollen:

Node.js

getAuth()
  .createUser({
    email: 'user@example.com',
    emailVerified: false,
    phoneNumber: '+11234567890',
    password: 'secretPassword',
    displayName: 'John Doe',
    photoURL: 'http://www.example.com/12345678/photo.png',
    disabled: false,
  })
  .then((userRecord) => {
    // See the UserRecord reference doc for the contents of userRecord.
    console.log('Successfully created new user:', userRecord.uid);
  })
  .catch((error) => {
    console.log('Error creating new user:', error);
  });
manage_users.js

Java

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

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

Python

user = auth.create_user(
    email='user@example.com',
    email_verified=False,
    phone_number='+15555550100',
    password='secretPassword',
    display_name='John Doe',
    photo_url='http://www.example.com/12345678/photo.png',
    disabled=False)
print(f'Sucessfully created new user: {user.uid}')

Go

params := (&auth.UserToCreate{}).
	Email("user@example.com").
	EmailVerified(false).
	PhoneNumber("+15555550100").
	Password("secretPassword").
	DisplayName("John Doe").
	PhotoURL("http://www.example.com/12345678/photo.png").
	Disabled(false)
u, err := client.CreateUser(ctx, params)
if err != nil {
	log.Fatalf("error creating user: %v\n", err)
}
log.Printf("Successfully created user: %v\n", u)
auth.go

C#

UserRecordArgs args = new UserRecordArgs()
{
    Email = "user@example.com",
    EmailVerified = false,
    PhoneNumber = "+11234567890",
    Password = "secretPassword",
    DisplayName = "John Doe",
    PhotoUrl = "http://www.example.com/12345678/photo.png",
    Disabled = false,
};
UserRecord userRecord = await FirebaseAuth.DefaultInstance.CreateUserAsync(args);
// See the UserRecord reference doc for the contents of userRecord.
Console.WriteLine($"Successfully created new user: {userRecord.Uid}");

Standardmäßig wird von Firebase Authentication ein zufälliges uid für den neuen Nutzer generiert. Wenn Sie stattdessen eine eigene uid für den neuen Nutzer angeben möchten, können Sie sie als Argument in die Methode zum Erstellen von Nutzern einfügen:

Node.js

getAuth()
  .createUser({
    uid: 'some-uid',
    email: 'user@example.com',
    phoneNumber: '+11234567890',
  })
  .then((userRecord) => {
    // See the UserRecord reference doc for the contents of userRecord.
    console.log('Successfully created new user:', userRecord.uid);
  })
  .catch((error) => {
    console.log('Error creating new user:', error);
  });
manage_users.js

Java

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

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

Python

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

Go

params := (&auth.UserToCreate{}).
	UID(uid).
	Email("user@example.com").
	PhoneNumber("+15555550100")
u, err := client.CreateUser(ctx, params)
if err != nil {
	log.Fatalf("error creating user: %v\n", err)
}
log.Printf("Successfully created user: %v\n", u)
auth.go

C#

UserRecordArgs args = new UserRecordArgs()
{
    Uid = "some-uid",
    Email = "user@example.com",
    PhoneNumber = "+11234567890",
};
UserRecord userRecord = await FirebaseAuth.DefaultInstance.CreateUserAsync(args);
// See the UserRecord reference doc for the contents of userRecord.
Console.WriteLine($"Successfully created new user: {userRecord.Uid}");

Es kann eine beliebige Kombination der folgenden Attribute angegeben werden:

Tabelle 1. Vom Vorgang zum Erstellen von Nutzern unterstützte Eigenschaften

Attribut Typ Beschreibung
uid String Die uid, die dem neu erstellten Nutzer zugewiesen werden soll. Muss ein String zwischen 1 und 128 Zeichen lang sein. Wenn nicht angegeben, wird automatisch ein zufälliger uid generiert. Kürzere uids bieten eine bessere Leistung.
email String Primäre E-Mail-Adresse des Nutzers. Geben Sie eine gültige E-Mail-Adresse ein.
emailVerified boolean Gibt an, ob die primäre E-Mail-Adresse des Nutzers bestätigt ist oder nicht. Wenn keine Angabe gemacht wird, lautet der Standardwert false.
phoneNumber String Primäre Telefonnummer des Nutzers. Muss eine gültige E.164-konforme Telefonnummer sein.
password String Das unverschlüsselte Passwort des Nutzers. Muss mindestens sechs Zeichen lang sein.
displayName String Der Anzeigename der Nutzer.
photoURL String Die Foto-URL des Nutzers.
disabled boolean Aktivierungsstatus des Nutzers. true für deaktiviert; false für aktiviert. Wenn keine Angabe gemacht wird, lautet der Standardwert false.

Die Methode zum Erstellen von Nutzern gibt ein UserRecord-Objekt für den neu erstellten Nutzer zurück.

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

Nutzer aktualisieren

Mit dem Firebase Admin SDK können Sie die Daten eines vorhandenen Nutzers ändern. Sie müssen einen uid und die Attribute angeben, die für diesen Nutzer aktualisiert werden sollen:

Node.js

getAuth()
  .updateUser(uid, {
    email: 'modifiedUser@example.com',
    phoneNumber: '+11234567890',
    emailVerified: true,
    password: 'newPassword',
    displayName: 'Jane Doe',
    photoURL: 'http://www.example.com/12345678/photo.png',
    disabled: true,
  })
  .then((userRecord) => {
    // See the UserRecord reference doc for the contents of userRecord.
    console.log('Successfully updated user', userRecord.toJSON());
  })
  .catch((error) => {
    console.log('Error updating user:', error);
  });
manage_users.js

Java

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

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

Python

user = auth.update_user(
    uid,
    email='user@example.com',
    phone_number='+15555550100',
    email_verified=True,
    password='newPassword',
    display_name='John Doe',
    photo_url='http://www.example.com/12345678/photo.png',
    disabled=True)
print(f'Sucessfully updated user: {user.uid}')

Go

params := (&auth.UserToUpdate{}).
	Email("user@example.com").
	EmailVerified(true).
	PhoneNumber("+15555550100").
	Password("newPassword").
	DisplayName("John Doe").
	PhotoURL("http://www.example.com/12345678/photo.png").
	Disabled(true)
u, err := client.UpdateUser(ctx, uid, params)
if err != nil {
	log.Fatalf("error updating user: %v\n", err)
}
log.Printf("Successfully updated user: %v\n", u)
auth.go

C#

UserRecordArgs args = new UserRecordArgs()
{
    Uid = uid,
    Email = "modifiedUser@example.com",
    PhoneNumber = "+11234567890",
    EmailVerified = true,
    Password = "newPassword",
    DisplayName = "Jane Doe",
    PhotoUrl = "http://www.example.com/12345678/photo.png",
    Disabled = true,
};
UserRecord userRecord = await FirebaseAuth.DefaultInstance.UpdateUserAsync(args);
// See the UserRecord reference doc for the contents of userRecord.
Console.WriteLine($"Successfully updated user: {userRecord.Uid}");

Es kann eine beliebige Kombination der folgenden Attribute angegeben werden:

Tabelle 2. Vom Vorgang „Nutzer aktualisieren“ unterstützte Attribute

Attribut Typ Beschreibung
email String Neue primäre E-Mail-Adresse des Nutzers. Geben Sie eine gültige E-Mail-Adresse ein.
emailVerified boolean Gibt an, ob die primäre E-Mail-Adresse des Nutzers bestätigt ist oder nicht. Wenn keine Angabe gemacht wird, lautet der Standardwert false.
phoneNumber String Die neue primäre Telefonnummer des Nutzers. Muss eine gültige E.164-konforme Telefonnummer sein. Legen Sie null fest, um die vorhandene Telefonnummer des Nutzers zu löschen.
password String Das neue unverschlüsselte Passwort des Nutzers. Muss mindestens sechs Zeichen lang sein.
displayName String | null Der neue Anzeigename der Nutzer Legen Sie null fest, um den vorhandenen Anzeigenamen des Nutzers zu löschen.
photoURL String | null Die neue Foto-URL des Nutzers. Mit null wird die vorhandene Foto-URL des Nutzers gelöscht. Wenn der Wert nicht null ist, muss es sich um eine gültige URL handeln.
disabled boolean Aktivierungsstatus des Nutzers. true für deaktiviert; false für aktiviert.

Die Methode „update user“ gibt ein aktualisiertes UserRecord-Objekt zurück, wenn das Update erfolgreich abgeschlossen wurde.

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

Nutzer löschen

Mit dem Firebase Admin SDK können Sie vorhandene Nutzer anhand ihrer uid löschen:

Node.js

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

Java

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

Python

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

Go

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

C#

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

Die Methode „delete user“ gibt ein leeres Ergebnis zurück, wenn der Löschvorgang erfolgreich abgeschlossen ist.

Wenn die angegebene uid keinem vorhandenen Nutzer entspricht oder der Nutzer aus einem anderen Grund nicht gelöscht werden kann, gibt die Methode „Nutzer löschen“ einen Fehler aus. Eine vollständige Liste der Fehlercodes mit Beschreibungen und Schritten zur Fehlerbehebung 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()-Event-Handler für Cloud Functions for Firebase ausgelöst. Das liegt daran, dass beim Löschen im Batch kein Nutzerlöschereignis für jeden Nutzer ausgelöst wird. Löschen Sie Nutzer einzeln, wenn für jeden gelöschten Nutzer Ereignisse zur Nutzerlöschung ausgelöst werden sollen.

Node.js

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

Java

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

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

Python

from firebase_admin import auth

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

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

Go

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

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

C#

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

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

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

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 mit Beschreibungen und Schritten zur Fehlerbehebung finden Sie unter Admin Authentication API-Fehler.

Alle Nutzer aufführen

Mit dem Firebase Admin SDK kann die gesamte Liste der Nutzer in Batches abgerufen werden:

Node.js

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

Java

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

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

Python

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

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

Go

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

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

C#

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

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

Jeder Batch von Ergebnissen enthält eine Liste von Nutzern sowie das Token für die nächste Seite, um den nächsten Batch von Nutzern aufzulisten. Wenn alle Nutzer bereits aufgelistet sind, wird kein pageToken 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. Jeder Wert, der größer als der Höchstwert ist, löst einen Argumentfehler aus. Wenn kein pageToken angegeben ist, werden die Nutzer von Beginn an nach uid sortiert aufgelistet.

Eine vollständige Liste der Fehlercodes mit Beschreibungen und Schritten zur Fehlerbehebung finden Sie unter Admin Authentication API-Fehler.

Passworthashes der aufgeführten Nutzer

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

Da Passwort-Hash-Werte vertraulich sind, hat das Dienstkonto des Firebase Admin SDK standardmäßig nicht die Berechtigung firebaseauth.configs.getHashConfig. Sie können einem Nutzer oder Dienstkonto keine Berechtigung direkt hinzufügen, aber indirekt, indem Sie eine benutzerdefinierte IAM-Rolle erstellen.

So erstellen Sie die benutzerdefinierte IAM-Rolle:

  1. Rufen Sie in der Google Cloud-Konsole 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 entsprechende Kästchen an.
  6. Klicken Sie auf HINZUFÜGEN.
  7. Klicken Sie auf ERSTELLEN, um die neue Rolle zu erstellen.

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

  1. Wählen Sie im Bereich IAM & Verwaltung die Option IAM aus.
  2. Wählen Sie den Dienst oder das Nutzerkonto aus der Liste der Mitglieder aus, um es zu bearbeiten.
  3. Klicken Sie auf WEITERE ROLLE HINZUFÜGEN.
  4. Suchen Sie nach der neuen benutzerdefinierten Rolle, die Sie zuvor erstellt haben.
  5. Klicken Sie auf SPEICHERN.