How to fix messaging/registration-token-not-registered in Firebase

// Node.js Admin SDK
async function sendNotificationWithErrorHandling(userId, message) {
  const user = await db.users.findUnique({
    where: { id: userId },
    select: { fcmToken: true }
  });

  if (!user.fcmToken) {
    console.log('User has no FCM token');
    return;
  }

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

    console.log('Notification sent:', response);
    return response;

  } catch (error) {
    // Check for registration token errors
    if (error.code === 'messaging/registration-token-not-registered' ||
        error.code === 'messaging/invalid-registration-token') {

      console.log('Token is no longer valid, removing:', user.fcmToken);

      // Delete the invalid token
      await db.users.update({
        where: { id: userId },
        data: {
          fcmToken: null,
          fcmTokenInvalidatedAt: new Date(),
          fcmTokenInvalidReason: error.code
        }
      });

      console.log('Invalid token removed for user:', userId);
      return null;
    }

    throw error;
  }
}

// Send to multiple users
const response = await admin.messaging().sendEachForMulticast({
  tokens: registrationTokens,
  notification: {
    title: 'Notification Title',
    body: 'Notification body'
  }
});

// Process failures
const tokensToDelete = [];

response.responses.forEach((resp, index) => {
  if (!resp.success) {
    const error = resp.error;
    console.error(`Send to token ${index} failed:`, error.code);

    // Mark for deletion
    if (error.code === 'messaging/registration-token-not-registered' ||
        error.code === 'messaging/invalid-registration-token') {
      tokensToDelete.push(registrationTokens[index]);
    }
  }
});

// Bulk delete invalid tokens
if (tokensToDelete.length > 0) {
  await db.users.updateMany({
    where: {
      fcmToken: { in: tokensToDelete }
    },
    data: {
      fcmToken: null,
      fcmTokenInvalidatedAt: new Date()
    }
  });
  console.log(`Removed ${tokensToDelete.length} invalid tokens`);
}

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

import { getMessaging, onMessage } from 'firebase/messaging';
import { initializeApp } from 'firebase/app';

const app = initializeApp(firebaseConfig);
const messaging = getMessaging(app);

// Listen for token refresh
messaging.onTokenRefresh(() => {
  getToken(messaging, { vapidKey: 'YOUR_VAPID_KEY' })
    .then(newToken => {
      console.log('FCM Token refreshed:', newToken);

      // Send new token to server
      fetch('/api/update-fcm-token', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ token: newToken })
      })
      .catch(err => console.error('Failed to update token:', err));
    });
});

class MyFirebaseMessagingService : FirebaseMessagingService() {
  override fun onNewToken(token: String) {
    super.onNewToken(token)
    Log.d(TAG, "Refreshed token: $token")

    // Send to your backend
    sendTokenToServer(token)
  }

  private fun sendTokenToServer(token: String) {
    val apiService = RetrofitClient.getInstance().create(ApiService::class.java)
    apiService.updateFcmToken(UpdateTokenRequest(token))
      .enqueue(object : Callback<Void> {
        override fun onResponse(call: Call<Void>, response: Response<Void>) {
          Log.d(TAG, "Token sent to server successfully")
        }

        override fun onFailure(call: Call<Void>, t: Throwable) {
          Log.e(TAG, "Failed to send token to server", t)
        }
      })
  }
}

import Firebase
import FirebaseMessaging

class AppDelegate: UIResponder, UIApplicationDelegate, MessagingDelegate {
  func messaging(_ messaging: Messaging, didReceiveRegistrationToken fcmToken: String?) {
    if let token = fcmToken {
      print("FCM token refreshed: \(token)")

      // Send to server
      sendTokenToServer(token)
    }
  }

  private func sendTokenToServer(_ token: String) {
    let urlString = "https://yourserver.com/api/update-fcm-token"
    guard let url = URL(string: urlString) else { return }

    var request = URLRequest(url: url)
    request.httpMethod = "POST"
    request.setValue("application/json", forHTTPHeaderField: "Content-Type")
    request.httpBody = try? JSONSerialization.data(
      withJSONObject: ["token": token]
    )

    URLSession.shared.dataTask(with: request).resume()
  }
}

// Token validation utility
function shouldSkipToken(tokenRecord) {
  // Skip if token is NULL
  if (!tokenRecord.fcmToken) {
    return true;
  }

  // Skip if token was invalidated recently
  if (tokenRecord.fcmTokenInvalidatedAt) {
    return true;
  }

  // Skip if token has not been updated in 30 days (potential stale token)
  const thirtyDaysAgo = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);
  if (new Date(tokenRecord.fcmTokenUpdatedAt) < thirtyDaysAgo) {
    console.warn('Token not updated in 30 days, skipping:', tokenRecord.id);
    return true;
  }

  return false;
}

// Before sending notifications
async function sendBulkNotifications(userIds, message) {
  const users = await db.users.findMany({
    where: { id: { in: userIds } },
    select: {
      id: true,
      fcmToken: true,
      fcmTokenUpdatedAt: true,
      fcmTokenInvalidatedAt: true
    }
  });

  const validTokens = users
    .filter(user => !shouldSkipToken(user))
    .map(user => user.fcmToken);

  if (validTokens.length === 0) {
    console.log('No valid tokens available');
    return;
  }

  const response = await admin.messaging().sendEachForMulticast({
    tokens: validTokens,
    notification: message
  });

  console.log(`Sent to ${response.successCount} devices, ${response.failureCount} failed`);
}

// Express.js example
app.post('/api/update-fcm-token', authenticateUser, async (req, res) => {
  try {
    const { token } = req.body;
    const userId = req.user.id;

    // Validate token format (FCM tokens are typically 150+ chars)
    if (!token || typeof token !== 'string' || token.length < 100) {
      return res.status(400).json({
        error: 'Invalid FCM token format'
      });
    }

    // Update user's token
    const updated = await db.users.update({
      where: { id: userId },
      data: {
        fcmToken: token,
        fcmTokenUpdatedAt: new Date(),
        fcmTokenInvalidatedAt: null,
        fcmTokenInvalidReason: null
      }
    });

    console.log('Token updated for user:', userId);
    res.json({
      success: true,
      message: 'Token updated',
      tokenLength: token.length
    });

  } catch (error) {
    console.error('Token update failed:', error);
    res.status(500).json({
      error: 'Failed to update token',
      message: error.message
    });
  }
});

// Next.js API route example
export async function POST(request: NextRequest) {
  try {
    const session = await getSession(request);
    if (!session) {
      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
    }

    const { token } = await request.json();

    if (!token || token.length < 100) {
      return NextResponse.json(
        { error: 'Invalid token format' },
        { status: 400 }
      );
    }

    await prisma.user.update({
      where: { id: session.user.id },
      data: {
        fcmToken: token,
        fcmTokenUpdatedAt: new Date()
      }
    });

    return NextResponse.json({ success: true });
  } catch (error) {
    return NextResponse.json(
      { error: 'Failed to update token' },
      { status: 500 }
    );
  }
}

// Scheduled job to clean up stale tokens (run daily/weekly)
async function cleanupStaleTokens() {
  const thirtyDaysAgo = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);

  const staleTokenCount = await db.users.updateMany({
    where: {
      fcmToken: { not: null },
      fcmTokenUpdatedAt: { lt: thirtyDaysAgo }
    },
    data: {
      fcmToken: null,
      fcmTokenInvalidatedAt: new Date(),
      fcmTokenInvalidReason: 'AUTO_CLEANUP_STALE'
    }
  });

  console.log(`Cleaned up ${staleTokenCount.count} stale tokens`);
  return staleTokenCount.count;
}

// Bull Queue example for scheduled job
const cleanupQueue = new Queue('token-cleanup', {
  connection: redis
});

cleanupQueue.process(async () => {
  return cleanupStaleTokens();
});

// Schedule to run daily at 2 AM
cleanupQueue.add(
  {},
  {
    repeat: {
      cron: '0 2 * * *'
    }
  }
);

// Node.js cron example
import cron from 'node-cron';

// Run cleanup every Sunday at 3 AM
cron.schedule('0 3 * * 0', async () => {
  console.log('Running scheduled token cleanup...');
  try {
    const removed = await cleanupStaleTokens();
    console.log(`Cleanup completed: removed ${removed} tokens`);
  } catch (error) {
    console.error('Cleanup failed:', error);
  }
});

// Add to your error handling
async function logTokenError(userId, token, errorCode) {
  await db.tokenErrors.create({
    data: {
      userId,
      token: token.substring(0, 20) + '...',  // Log partial token for privacy
      errorCode,
      timestamp: new Date(),
      deviceInfo: userAgent
    }
  });
}

// Use in error handler
if (error.code === 'messaging/registration-token-not-registered') {
  await logTokenError(userId, token, error.code);
  // ... delete token
}