How to fix messaging/SENDER_ID_MISMATCH: Registration token tied to different sender in Firebase

// Initialize Firebase Admin SDK with correct service account
const admin = require('firebase-admin');

// Method 1: Using environment variable (recommended for production)
admin.initializeApp({
  credential: admin.credential.applicationDefault(),
  projectId: 'your-correct-project-id' // Verify this matches token source
});

// Method 2: Using service account JSON file
const serviceAccount = require('./path/to/serviceAccountKey.json');
admin.initializeApp({
  credential: admin.credential.cert(serviceAccount)
});

// Verify the project ID
console.log('Current project ID:', admin.app().options.projectId);

// Compare with where tokens were generated:
// - Check client app's google-services.json (Android)
// - Check client app's GoogleService-Info.plist (iOS)
// - Check web app's firebase config

// On client (Android/iOS/Web), get a fresh token
// Example for web:
import { getMessaging, getToken } from "firebase/messaging";

const messaging = getMessaging();

// Request permission and get token
async function requestPermissionAndGetToken() {
  try {
    const permission = await Notification.requestPermission();
    if (permission === 'granted') {
      const token = await getToken(messaging, {
        vapidKey: 'YOUR_VAPID_KEY' // From Firebase Console > Cloud Messaging
      });

      console.log('New FCM token:', token);

      // Send this new token to your server
      await sendTokenToServer(token);

      return token;
    }
  } catch (error) {
    console.error('Error getting token:', error);
  }
}

// For existing apps, you can also listen for token refresh:
import { onTokenRefresh } from "firebase/messaging";

onTokenRefresh(messaging, () => {
  getToken(messaging).then((refreshedToken) => {
    console.log('Token refreshed:', refreshedToken);
    sendTokenToServer(refreshedToken);
  });
});

{
  "project_info": {
    "project_number": "123456789012",  // This is the sender ID
    "project_id": "your-project-id",
    "storage_bucket": "your-project-id.appspot.com"
  },
  "client": [...],
  "configuration_version": "1"
}

<key>PROJECT_ID</key>
<string>your-project-id</string>
<key>GOOGLE_APP_ID</key>
<string>1:123456789012:ios:abc123def456</string>

const firebaseConfig = {
  apiKey: "your-api-key",
  authDomain: "your-project-id.firebaseapp.com",
  projectId: "your-project-id",  // Must match server project
  storageBucket: "your-project-id.appspot.com",
  messagingSenderId: "123456789012",  // This is the sender ID
  appId: "1:123456789012:web:abc123def456"
};

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

async function sendMessageWithValidation(token, message) {
  try {
    const response = await admin.messaging().send({
      token: token,
      notification: {
        title: message.title,
        body: message.body
      }
    });

    console.log('Message sent successfully:', response);
    return { success: true, response };

  } catch (error) {
    console.error('Error sending message:', error.message);

    // Check for SENDER_ID_MISMATCH specifically
    if (error.code === 'messaging/sender-id-mismatch' ||
        error.message.includes('SENDER_ID_MISMATCH')) {

      console.log('Token belongs to different project:', token);

      // Remove this token from your database
      await removeInvalidTokenFromDatabase(token);

      // Optionally notify client to refresh token
      await notifyClientToRefreshToken(token);

      return {
        success: false,
        error: 'SENDER_ID_MISMATCH',
        action: 'token_removed'
      };
    }

    // Handle other errors
    return { success: false, error: error.message };
  }
}

// Helper function to remove invalid token
async function removeInvalidTokenFromDatabase(token) {
  // Remove from your database/Redis cache
  await db.tokens.deleteOne({ token: token });
  console.log('Removed invalid token from database');
}

// Helper to notify client (if you have a way to communicate back)
async function notifyClientToRefreshToken(token) {
  // Could use other channels like WebSockets, database flags, etc.
  // This depends on your app architecture
}

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

async function validateToken(token) {
  try {
    // This will fail if token is from different project
    const info = await admin.messaging().getRegistrationTokenInfo(token);

    console.log('Token is valid:', {
      projectId: info.projectId,
      appId: info.appId,
      platform: info.platform,
      token: token.substring(0, 20) + '...' // Log partial for security
    });

    return { valid: true, info };

  } catch (error) {
    if (error.code === 'messaging/sender-id-mismatch') {
      console.log('Token belongs to different project');
      return { valid: false, reason: 'SENDER_ID_MISMATCH' };
    }

    console.error('Token validation error:', error.message);
    return { valid: false, reason: error.code };
  }
}

// Usage: Validate tokens before storing or using them
const token = 'your-fcm-token';
const validation = await validateToken(token);

if (!validation.valid) {
  if (validation.reason === 'SENDER_ID_MISMATCH') {
    console.log('Do not store this token - it's from wrong project');
    // Prompt user to re-register for notifications
  }
}

// Support both old and new projects during migration
   const adminOld = require('firebase-admin');
   const adminNew = require('firebase-admin');

   // Initialize two app instances
   const oldApp = adminOld.initializeApp(
     oldServiceAccount,
     'old-project'
   );

   const newApp = adminNew.initializeApp(
     newServiceAccount,
     'new-project'
   );

   // Determine which project to use based on token
   async function sendMessage(token, message) {
     // Try new project first (most tokens should be new)
     try {
       const messaging = newApp.messaging();
       return await messaging.send({ token, ...message });
     } catch (error) {
       if (error.code === 'messaging/sender-id-mismatch') {
         // Token belongs to old project
         const messaging = oldApp.messaging();
         return await messaging.send({ token, ...message });
       }
       throw error;
     }
   }