How to fix auth/maximum-user-count-exceeded: User import count exceeds maximum in Firebase

const admin = require('firebase-admin');

// Initialize Firebase Admin SDK
admin.initializeApp({
  credential: admin.credential.applicationDefault(),
});

async function importUsersInBatches(users) {
  const BATCH_SIZE = 1000; // Firebase's maximum per request
  const totalUsers = users.length;
  let importedCount = 0;
  let failedCount = 0;
  const errors = [];

  console.log(`Starting import of ${totalUsers} users...`);

  // Process users in batches
  for (let i = 0; i < totalUsers; i += BATCH_SIZE) {
    const batch = users.slice(i, i + BATCH_SIZE);
    const batchNumber = Math.floor(i / BATCH_SIZE) + 1;
    const totalBatches = Math.ceil(totalUsers / BATCH_SIZE);

    console.log(`Processing batch ${batchNumber}/${totalBatches} (${batch.length} users)...`);

    try {
      // Import this batch
      const result = await admin.auth().importUsers(batch);

      // Track results
      importedCount += result.successCount;
      failedCount += result.failureCount;

      // Log any per-user errors
      if (result.errors && result.errors.length > 0) {
        result.errors.forEach((error) => {
          errors.push({
            batch: batchNumber,
            index: error.index,
            error: error.error,
          });
          console.error(
            `  Failed to import user at index ${error.index}: ${error.error.code} - ${error.error.message}`
          );
        });
      }

      console.log(`  Batch ${batchNumber}: ${result.successCount} succeeded, ${result.failureCount} failed`);

      // Optional: Add delay between batches to avoid rate limits
      if (i + BATCH_SIZE < totalUsers) {
        await new Promise(resolve => setTimeout(resolve, 100)); // 100ms delay
      }
    } catch (error) {
      console.error(`Batch ${batchNumber} failed completely:`, error.code, error.message);

      // If we hit maximum-user-count-exceeded, this batch is too large
      if (error.code === 'auth/maximum-user-count-exceeded') {
        console.error('Batch size exceeds 1,000 users - check your batching logic!');
        throw error; // Stop processing
      }

      // For other errors, continue with next batch
      failedCount += batch.length;
    }
  }

  console.log(`
Import complete:`);
  console.log(`  Total users: ${totalUsers}`);
  console.log(`  Successfully imported: ${importedCount}`);
  console.log(`  Failed: ${failedCount}`);
  console.log(`  Total batches: ${Math.ceil(totalUsers / BATCH_SIZE)}`);

  return {
    totalUsers,
    importedCount,
    failedCount,
    errors,
  };
}

// Example: Load users from JSON file
const fs = require('fs');
const users = JSON.parse(fs.readFileSync('users.json', 'utf8'));

// Convert to Firebase user format
const firebaseUsers = users.map(user => ({
  uid: user.id,
  email: user.email,
  emailVerified: user.emailVerified || false,
  displayName: user.displayName,
  photoURL: user.photoURL,
  disabled: user.disabled || false,
}));

// Import users
importUsersInBatches(firebaseUsers)
  .then(results => {
    console.log('Import results:', results);
    process.exit(0);
  })
  .catch(error => {
    console.error('Import failed:', error);
    process.exit(1);
  });

const admin = require('firebase-admin');
const pLimit = require('p-limit'); // npm install p-limit

admin.initializeApp({
  credential: admin.credential.applicationDefault(),
});

async function importUsersWithConcurrency(users) {
  const BATCH_SIZE = 1000;
  const CONCURRENT_BATCHES = 5; // Process 5 batches simultaneously
  const totalUsers = users.length;
  const limit = pLimit(CONCURRENT_BATCHES);

  console.log(`Importing ${totalUsers} users with ${CONCURRENT_BATCHES} concurrent batches...`);

  // Split users into batches
  const batches = [];
  for (let i = 0; i < totalUsers; i += BATCH_SIZE) {
    batches.push({
      users: users.slice(i, i + BATCH_SIZE),
      batchNumber: Math.floor(i / BATCH_SIZE) + 1,
    });
  }

  console.log(`Created ${batches.length} batches`);

  // Process batches with concurrency limit
  const results = await Promise.all(
    batches.map(({ users: batchUsers, batchNumber }) =>
      limit(async () => {
        const startTime = Date.now();

        try {
          const result = await admin.auth().importUsers(batchUsers);
          const duration = Date.now() - startTime;

          console.log(
            `Batch ${batchNumber}/${batches.length}: ${result.successCount} succeeded, ${result.failureCount} failed (${duration}ms)`
          );

          return {
            batchNumber,
            successCount: result.successCount,
            failureCount: result.failureCount,
            errors: result.errors || [],
            duration,
          };
        } catch (error) {
          console.error(`Batch ${batchNumber} failed:`, error.code, error.message);

          return {
            batchNumber,
            successCount: 0,
            failureCount: batchUsers.length,
            errors: [{ error: { code: error.code, message: error.message } }],
            duration: Date.now() - startTime,
          };
        }
      })
    )
  );

  // Aggregate results
  const summary = results.reduce(
    (acc, result) => ({
      totalImported: acc.totalImported + result.successCount,
      totalFailed: acc.totalFailed + result.failureCount,
      totalBatches: acc.totalBatches + 1,
      avgDuration: acc.avgDuration + result.duration,
      errors: [...acc.errors, ...result.errors],
    }),
    { totalImported: 0, totalFailed: 0, totalBatches: 0, avgDuration: 0, errors: [] }
  );

  summary.avgDuration = Math.round(summary.avgDuration / summary.totalBatches);

  console.log(`
Import Summary:`);
  console.log(`  Total users: ${totalUsers}`);
  console.log(`  Successfully imported: ${summary.totalImported}`);
  console.log(`  Failed: ${summary.totalFailed}`);
  console.log(`  Total batches: ${summary.totalBatches}`);
  console.log(`  Average batch duration: ${summary.avgDuration}ms`);
  console.log(`  Total errors: ${summary.errors.length}`);

  return summary;
}

// Example usage
const users = require('./users.json');
importUsersWithConcurrency(users)
  .then(summary => {
    if (summary.totalFailed > 0) {
      console.log(`
Writing ${summary.errors.length} errors to error.log`);
      require('fs').writeFileSync(
        'import-errors.json',
        JSON.stringify(summary.errors, null, 2)
      );
    }
    process.exit(summary.totalFailed > 0 ? 1 : 0);
  })
  .catch(error => {
    console.error('Import failed:', error);
    process.exit(1);
  });

const admin = require('firebase-admin');

async function importUsersWithPasswords(users) {
  const BATCH_SIZE = 1000;

  // Prepare users with password hashes
  const firebaseUsers = users.map(user => ({
    uid: user.id,
    email: user.email,
    emailVerified: user.emailVerified,
    displayName: user.displayName,
    photoURL: user.photoURL,
    disabled: false,

    // Password hash from your existing system
    passwordHash: Buffer.from(user.passwordHash, 'base64'),
    passwordSalt: Buffer.from(user.passwordSalt, 'base64'),
  }));

  // Define password hashing options
  const options = {
    hash: {
      algorithm: 'BCRYPT', // or 'SCRYPT', 'PBKDF2_SHA256', 'STANDARD_SCRYPT', etc.
      // Additional parameters depend on algorithm:
      // For BCRYPT: no additional parameters needed
      // For SCRYPT: rounds, memoryCost, etc.
    },
  };

  // Import in batches
  for (let i = 0; i < firebaseUsers.length; i += BATCH_SIZE) {
    const batch = firebaseUsers.slice(i, i + BATCH_SIZE);

    try {
      const result = await admin.auth().importUsers(batch, options);
      console.log(`Batch imported: ${result.successCount} succeeded, ${result.failureCount} failed`);

      // Handle errors
      if (result.errors && result.errors.length > 0) {
        result.errors.forEach(error => {
          console.error(`User ${batch[error.index].email} failed: ${error.error.message}`);
        });
      }
    } catch (error) {
      if (error.code === 'auth/maximum-user-count-exceeded') {
        console.error('Batch exceeds 1,000 user limit!');
        throw error;
      }
      console.error('Batch import failed:', error.message);
    }

    // Small delay between batches
    await new Promise(resolve => setTimeout(resolve, 100));
  }
}

// Example: Import from bcrypt-hashed passwords
const usersWithBcrypt = [
  {
    id: 'user1',
    email: 'user1@example.com',
    emailVerified: true,
    displayName: 'User One',
    photoURL: null,
    passwordHash: 'JDJhJDEwJC4uLg==', // Base64-encoded bcrypt hash
    passwordSalt: '', // Bcrypt includes salt in hash
  },
  // ... more users
];

importUsersWithPasswords(usersWithBcrypt)
  .then(() => console.log('Import complete'))
  .catch(error => console.error('Import failed:', error));

const admin = require('firebase-admin');
const fs = require('fs');

class UserImporter {
  constructor(users) {
    this.users = users;
    this.BATCH_SIZE = 1000;
    this.MAX_RETRIES = 3;
    this.progressFile = 'import-progress.json';
    this.loadProgress();
  }

  loadProgress() {
    if (fs.existsSync(this.progressFile)) {
      this.progress = JSON.parse(fs.readFileSync(this.progressFile, 'utf8'));
      console.log(`Resuming from batch ${this.progress.lastCompletedBatch + 1}`);
    } else {
      this.progress = {
        lastCompletedBatch: -1,
        totalImported: 0,
        totalFailed: 0,
        failedBatches: [],
      };
    }
  }

  saveProgress() {
    fs.writeFileSync(this.progressFile, JSON.stringify(this.progress, null, 2));
  }

  async importBatch(batch, batchNumber, retryCount = 0) {
    try {
      const result = await admin.auth().importUsers(batch);

      console.log(
        `Batch ${batchNumber}: ${result.successCount} succeeded, ${result.failureCount} failed`
      );

      // Log individual errors
      if (result.errors && result.errors.length > 0) {
        const errorLog = {
          batch: batchNumber,
          timestamp: new Date().toISOString(),
          errors: result.errors.map(err => ({
            index: err.index,
            uid: batch[err.index].uid,
            email: batch[err.index].email,
            errorCode: err.error.code,
            errorMessage: err.error.message,
          })),
        };

        // Append to error log file
        fs.appendFileSync(
          'import-errors.jsonl',
          JSON.stringify(errorLog) + '\n'
        );
      }

      return result;
    } catch (error) {
      if (error.code === 'auth/maximum-user-count-exceeded') {
        console.error(`Batch ${batchNumber} exceeds 1,000 user limit - this should not happen!`);
        throw error;
      }

      // Retry on transient errors
      if (retryCount < this.MAX_RETRIES) {
        const delay = Math.pow(2, retryCount) * 1000; // Exponential backoff
        console.log(`Batch ${batchNumber} failed, retrying in ${delay}ms... (attempt ${retryCount + 1}/${this.MAX_RETRIES})`);
        await new Promise(resolve => setTimeout(resolve, delay));
        return this.importBatch(batch, batchNumber, retryCount + 1);
      }

      console.error(`Batch ${batchNumber} failed after ${this.MAX_RETRIES} retries:`, error.message);

      // Mark entire batch as failed
      return {
        successCount: 0,
        failureCount: batch.length,
        errors: [],
      };
    }
  }

  async import() {
    const totalBatches = Math.ceil(this.users.length / this.BATCH_SIZE);
    const startBatch = this.progress.lastCompletedBatch + 1;

    console.log(`Importing ${this.users.length} users in ${totalBatches} batches...`);
    console.log(`Starting from batch ${startBatch + 1}`);

    for (let i = startBatch; i < totalBatches; i++) {
      const startIndex = i * this.BATCH_SIZE;
      const batch = this.users.slice(startIndex, startIndex + this.BATCH_SIZE);
      const batchNumber = i + 1;

      console.log(`
Processing batch ${batchNumber}/${totalBatches} (${batch.length} users)...`);

      const result = await this.importBatch(batch, batchNumber);

      // Update progress
      this.progress.totalImported += result.successCount;
      this.progress.totalFailed += result.failureCount;
      this.progress.lastCompletedBatch = i;

      if (result.failureCount > 0) {
        this.progress.failedBatches.push(batchNumber);
      }

      this.saveProgress();

      // Progress bar
      const percentComplete = ((i + 1) / totalBatches * 100).toFixed(1);
      console.log(`Progress: ${percentComplete}% (${this.progress.totalImported} imported, ${this.progress.totalFailed} failed)`);

      // Small delay between batches
      if (i < totalBatches - 1) {
        await new Promise(resolve => setTimeout(resolve, 100));
      }
    }

    console.log(`
=== Import Complete ===`);
    console.log(`Total users: ${this.users.length}`);
    console.log(`Successfully imported: ${this.progress.totalImported}`);
    console.log(`Failed: ${this.progress.totalFailed}`);
    console.log(`Failed batches: ${this.progress.failedBatches.join(', ') || 'none'}`);

    // Clean up progress file on success
    if (this.progress.totalFailed === 0) {
      fs.unlinkSync(this.progressFile);
      console.log('Progress file cleaned up');
    }

    return this.progress;
  }
}

// Usage
admin.initializeApp({
  credential: admin.credential.applicationDefault(),
});

const users = JSON.parse(fs.readFileSync('users.json', 'utf8'));
const importer = new UserImporter(users);

importer.import()
  .then(results => {
    console.log('Final results:', results);
    process.exit(results.totalFailed > 0 ? 1 : 0);
  })
  .catch(error => {
    console.error('Import failed:', error);
    process.exit(1);
  });

const admin = require('firebase-admin');

function validateBatchSize(users, batchSize = 1000) {
  if (!Array.isArray(users)) {
    throw new Error('Users must be an array');
  }

  if (users.length === 0) {
    throw new Error('Users array is empty');
  }

  if (users.length > batchSize) {
    throw new Error(
      `Batch size (${users.length}) exceeds Firebase limit (${batchSize}). Split into multiple batches.`
    );
  }

  return true;
}

async function safeImportUsers(users) {
  const BATCH_SIZE = 1000;

  // Validate entire array
  if (!Array.isArray(users) || users.length === 0) {
    throw new Error('Invalid users array');
  }

  // If within limit, import directly
  if (users.length <= BATCH_SIZE) {
    validateBatchSize(users, BATCH_SIZE);
    return admin.auth().importUsers(users);
  }

  // Otherwise, batch automatically
  console.log(`${users.length} users exceed limit, batching automatically...`);

  const results = {
    totalSuccess: 0,
    totalFailure: 0,
    batchResults: [],
  };

  for (let i = 0; i < users.length; i += BATCH_SIZE) {
    const batch = users.slice(i, i + BATCH_SIZE);

    // Double-check batch size (should never fail, but defensive)
    if (batch.length > BATCH_SIZE) {
      throw new Error(`Internal error: Batch ${i / BATCH_SIZE + 1} exceeds limit`);
    }

    try {
      const result = await admin.auth().importUsers(batch);
      results.totalSuccess += result.successCount;
      results.totalFailure += result.failureCount;
      results.batchResults.push({
        batchNumber: i / BATCH_SIZE + 1,
        successCount: result.successCount,
        failureCount: result.failureCount,
      });

      console.log(`Batch ${i / BATCH_SIZE + 1}: ${result.successCount} succeeded`);
    } catch (error) {
      console.error(`Batch ${i / BATCH_SIZE + 1} failed:`, error.message);
      results.totalFailure += batch.length;
    }

    await new Promise(resolve => setTimeout(resolve, 100));
  }

  return results;
}

// Example with validation
const users = loadUsersFromDatabase(); // Your user loading logic

safeImportUsers(users)
  .then(results => {
    console.log('Import complete:', results);
  })
  .catch(error => {
    console.error('Import failed:', error.message);
    process.exit(1);
  });