How to fix messaging/invalid-registration-token: Token format incorrect in Firebase

// Node.js Admin SDK
console.log('Token length:', registrationToken.length);
console.log('Token preview:', registrationToken.substring(0, 50) + '...');
console.log('Token type:', typeof registrationToken);

// Check for common issues
if (registrationToken.includes(' ')) {
  console.error('Token contains whitespace!');
}
if (registrationToken.startsWith('"') || registrationToken.endsWith('"')) {
  console.error('Token has quotes!');
}

-- Check your database schema
-- FCM tokens can be 200+ characters
ALTER TABLE users ALTER COLUMN fcm_token TYPE VARCHAR(255);

-- Verify stored token integrity
SELECT
  user_id,
  LENGTH(fcm_token) as token_length,
  fcm_token
FROM users
WHERE fcm_token IS NOT NULL;

// Bad - may trim whitespace or modify string
const token = req.body.token.trim();

// Good - use exact token from client
const token = req.body.token;

// Store in database
await db.users.update({
  where: { id: userId },
  data: { fcmToken: token } // Store exactly as received
});

import { getMessaging, getToken } from 'firebase/messaging';

async function getFCMToken() {
  try {
    const messaging = getMessaging();
    const token = await getToken(messaging, {
      vapidKey: 'YOUR_VAPID_KEY'
    });

    if (!token) {
      throw new Error('No registration token available');
    }

    console.log('FCM Token:', token);
    return token;
  } catch (error) {
    console.error('Error getting FCM token:', error);
    // Don't send null/undefined to server
    throw error;
  }
}

FirebaseMessaging.getInstance().token.addOnCompleteListener { task ->
    if (!task.isSuccessful) {
        Log.w(TAG, "Fetching FCM token failed", task.exception)
        return@addOnCompleteListener
    }

    val token = task.result
    Log.d(TAG, "FCM Token: $token")

    // Send to your server
    sendTokenToServer(token)
}

Messaging.messaging().token { token, error in
    if let error = error {
        print("Error fetching FCM token: \(error)")
        return
    }

    if let token = token {
        print("FCM Token: \(token)")
        self.sendTokenToServer(token)
    }
}

// Node.js Admin SDK
function validateFCMToken(token) {
  // Basic format checks
  if (!token || typeof token !== 'string') {
    return { valid: false, reason: 'Token is null or not a string' };
  }

  if (token.length < 100) {
    return { valid: false, reason: 'Token too short (likely truncated)' };
  }

  if (token.includes(' ') || token.includes('\n')) {
    return { valid: false, reason: 'Token contains whitespace' };
  }

  if (!/^[a-zA-Z0-9_-]+$/.test(token)) {
    return { valid: false, reason: 'Token contains invalid characters' };
  }

  return { valid: true };
}

// Use before sending
const validation = validateFCMToken(registrationToken);
if (!validation.valid) {
  console.error('Invalid token:', validation.reason);
  // Remove from database or mark as invalid
  await db.users.update({
    where: { fcmToken: registrationToken },
    data: { fcmToken: null, fcmTokenInvalidatedAt: new Date() }
  });
  throw new Error(`Invalid FCM token: ${validation.reason}`);
}

// Proceed with sending
await admin.messaging().send({
  token: registrationToken,
  notification: {
    title: 'Test',
    body: 'Message'
  }
});

// Node.js Admin SDK with error handling
async function sendNotification(userId, message) {
  const user = await db.users.findUnique({ where: { id: userId } });

  if (!user.fcmToken) {
    throw new Error('User has no FCM token');
  }

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

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

  } catch (error) {
    console.error('FCM send error:', error.code, error.message);

    // Handle invalid token errors
    if (error.code === 'messaging/invalid-registration-token' ||
        error.code === 'messaging/registration-token-not-registered') {

      console.log('Removing invalid token for user:', userId);

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

    throw error;
  }
}

// Send to multiple tokens with error handling
const response = await admin.messaging().sendEachForMulticast({
  tokens: registrationTokens,
  notification: {
    title: 'Batch Message',
    body: 'Content'
  }
});

// Process responses
const tokensToRemove = [];

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

    if (error.code === 'messaging/invalid-registration-token' ||
        error.code === 'messaging/registration-token-not-registered') {
      tokensToRemove.push(registrationTokens[idx]);
    }
  }
});

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