Firebase Errors

This error occurs when a user lacks authorization to read or write a specific Firestore document. It's caused by security rules denying access, unauthenticated users, or insufficient user permissions. Fix it by reviewing security rules, ensuring proper user authentication, and configuring rules to grant appropriate access.

This error occurs when a Firestore query contains more than 30 OR conditions (disjunctions), exceeding Firestore's query complexity limit. To fix it, you need to restructure your query to use fewer disjunctions or implement alternative filtering approaches.

This Firebase Authentication error occurs when email action handlers (password reset, email verification) are called without a valid continue URL. The continue URL redirects users after completing the action and must be properly configured in your Firebase project settings and API calls.

This Firebase Cloud Messaging error occurs when the request parameters sent to the FCM API are invalid, malformed, or contain unsupported values. Common causes include incorrect token format, invalid message structure, or unsupported payload keys.

The Firebase Emulator Suite runs Firestore and Storage emulators inside a JVM, so starting the suite requires a Java JDK 11+ that the CLI can execute. This error means the CLI failed to spawn `java -version` during initialization, which stops every Java-backed emulator before it can boot.

Firestore rejects any write that would make a document larger than 1 MiB (1,048,576 bytes). That limit counts every field name, nested map/array, and binary/text value in the document. The fix is to split the payload into multiple documents/subcollections or move large blobs outside Firestore before writing.

This error occurs when you attempt to create or import a user with a custom UID that already exists in Firebase. Fix it by checking if the user exists first or letting Firebase auto-generate unique UIDs.

This error occurs when a Firestore transaction or batched write operation exceeds the maximum request size of 10 MiB, typically due to writing too many documents or large index updates in a single operation.

This error occurs when configuring an OIDC or OAuth provider in Firebase Authentication with invalid responseType settings. Either multiple response types are set to true, or none are enabled when exactly one must be.

This error occurs when using Firebase Authentication's ActionCodeSettings with Android-specific options like installIfNotAvailable or minimumVersion without providing the required androidPackageName parameter.

Firebase rejects passwords that do not meet its security requirements. By default, passwords must be at least 6 characters long, but you can enforce stronger policies through the Firebase console.

This error occurs when configuring an OpenID Connect (OIDC) provider in Firebase Authentication without providing the required OAuth client secret.

The UNAVAILABLE error in Firebase Cloud Messaging indicates that the FCM server is temporarily overloaded or under maintenance and cannot process your request at this time.

Firebase Analytics enforces a limit of 25 parameters per custom event. This error occurs when your app attempts to log an event with more than the allowed number of parameters, causing the event to be rejected by the Firebase Analytics service.

The FCM registration token is no longer valid because the app was uninstalled, the token expired after 270 days of inactivity, or the app instance was unregistered from Firebase Cloud Messaging.

This Firebase Cloud Messaging error occurs when a single device receives messages faster than the rate limit allows. Firebase imposes per-device message rate limits to prevent abuse and ensure service stability. To fix this, you need to implement message throttling, batch notifications, or adjust your sending strategy.

This error occurs when attempting to set custom claims on a Firebase user that exceed the 1000-byte size limit. Firebase restricts custom claims to keep authentication tokens lightweight and performant.

This Firebase Firestore error occurs when setDoc() or updateDoc() receives invalid data in the document parameter. The document must be a plain JavaScript object. Fix it by ensuring you're passing a valid plain object and not a DocumentReference, class instance, or malformed data.

Firebase returns a service unavailable error when it cannot process your request, typically due to temporary service disruptions, network connectivity issues, or device offline conditions with no cached data. This is usually a transient error that can be resolved by implementing retry logic with exponential backoff.

The INVALID_ARGUMENT error occurs when Firebase receives malformed or invalid arguments in your request. This error can happen in Firestore queries, Cloud Functions, Cloud Messaging, Authentication, and the Firebase CLI. Common causes include incorrect data types, missing required fields, invalid field names, or configuration errors.

This generic error occurs when Firebase Storage encounters an unexpected issue that doesn't fit standard error codes. Common causes include missing IAM permissions, incorrect project setup, network issues, or SDK version conflicts. The fix involves checking browser console for detailed error messages, verifying service account permissions, and ensuring Storage is properly enabled.

This error occurs when Firebase Cloud Messaging rejects a registration token because it is invalid, expired, unregistered, or no longer recognized by FCM. The fix involves validating tokens, removing stale tokens, refreshing tokens on the client side, and implementing proper token lifecycle management.

This Firebase Remote Config error occurs when you try to activate a configuration that has already been activated. Remote Config maintains version control, and this error prevents redundant activations that could cause version confusion or unnecessary updates. The fix involves checking activation status before attempting to activate and implementing proper version tracking.

This Firebase Authentication error occurs when attempting to set a user's display name with an empty string, null, or undefined value. The fix involves ensuring you always provide a valid non-empty string when setting the displayName property through createUser(), updateUser(), or updateProfile() methods.

This error occurs when your Firestore query combines filters and sorting in a way that requires a composite index. Learn how to create the missing index using the Firebase console, CLI, or by following the automatic error link.

This error occurs when Firebase Storage cannot identify or access the Firebase project, typically because the project was not properly initialized, the project ID is missing or incorrect in the configuration, or Cloud Storage has not been set up for the project.

This error occurs when your app lacks the necessary permissions to read or write files in Firebase Cloud Storage. Learn how to authenticate users, configure security rules, and fix access issues in your Firebase project.

The "storage/object-not-found" error occurs when Firebase Storage cannot locate a file at the path you're trying to access. This happens when files are deleted, paths are incorrect, or uploads haven't completed. Fix it by verifying the file exists, checking your path syntax, and handling upload timing.

This Firebase Admin SDK error occurs when you attempt to set the emailVerified property to a non-boolean value. The emailVerified field only accepts true or false, not strings, numbers, or other types. Fix by ensuring you pass a boolean value when creating or updating users.

This Firebase Storage error occurs when the file checksum calculated on the client does not match the checksum validated by the server during upload. This indicates data corruption during transmission, typically caused by network interruptions or unstable connections. The solution is to retry the upload with proper error handling.

This Firebase Authentication error occurs when your app tries to use a dynamic link domain that hasn't been configured or authorized for your Firebase project. The fix involves configuring dynamic link domains in the Firebase Console and updating your app's configuration.

This Firebase Cloud Messaging error occurs when calling FCM methods with incorrect parameters, such as wrong data types, missing required fields, or invalid method signatures. It typically indicates a mismatch between your code and the Firebase Admin SDK API requirements.

This Firebase Authentication error occurs when you attempt to update a user's last sign-in time with an invalid or malformed UTC date string. The error typically appears when using the Firebase Admin SDK to modify user records programmatically, especially during user migration, data synchronization, or custom authentication workflows.

This error occurs when the request payload to a Firebase Callable Function is incorrectly formatted. The issue typically stems from extra fields in the request body, missing the required "data" field, or sending non-JSON-serializable data.

This Firebase Storage error occurs when the local file being uploaded is modified, deleted, or saved again while the upload is in progress. Firebase uses the Blob.slice() API to split files into 256KB chunks for resumable uploads, and detects when the underlying file has changed mid-upload.

This Firebase Authentication error occurs when you attempt to create or update a user with an invalid creation time timestamp.

This error occurs when Firebase Storage is initialized without specifying a storageBucket property. The fix involves adding your Cloud Storage bucket URL to the Firebase configuration object during initialization.

Firebase Cloud Messaging throws this error when too many notifications hit the same token or topic inside FCM’s per-target quota window. Spread the burst over five minutes or request a temporary quota bump before retrying.

The Spark (free) Firebase plan caps Firestore at 50,000 document reads per 24-hour window, so once your project consumes the allotment Firestore returns a ResourceExhausted error and blocks any further reads until the quota resets. Confirm the quota usage, upgrade to Blaze, and cut the number of reads (caching, aggregation, alerts, etc.) so you no longer burn through the free limit.

The Firebase Admin SDK enforces session cookies to last between five minutes and two weeks, so creating a session cookie with a shorter or longer duration fails with this error and prevents the login endpoint from issuing authenticated cookies.

Firebase rejects continue URLs that point to domains outside Authentication → Settings → Authorized Domains, so email-action or redirect flows fail with auth/unauthorized-continue-uri. Whitelist the domain and make sure ActionCodeSettings.url uses that host before sending links.

Firebase Storage throws this error when you subscribe to upload task updates with an unsupported event label. The SDK only recognizes the built-in state listeners that report running, paused, or progress updates, so any other event string triggers the invalid-event-name payload.

This Firebase Authentication error occurs when the continue URL provided for email actions (password reset, email verification) is invalid, malformed, or not authorized. The continue URL must be a properly formatted URL with an authorized domain that matches your Firebase project configuration.

This Firebase Authentication error occurs when your application tries to use an expired ID token for authentication. Firebase ID tokens have a limited lifespan (typically 1 hour) and must be refreshed before they expire. The fix involves implementing proper token refresh logic and handling token expiration gracefully in your application.

This Firebase Authentication error occurs when your code attempts to use an invalid or unsupported provider ID for authentication operations. The fix involves verifying that you're using correct provider IDs like 'google.com', 'facebook.com', etc., and ensuring proper Firebase Authentication configuration.

This Firebase Cloud Messaging error occurs when Firebase cannot authenticate with Apple Push Notification service (APNs) using the provided certificate or with web push services using the provided auth key. The error indicates authentication failures with third-party push notification services that Firebase relies on for message delivery.

This Firebase Authentication error occurs when importing user accounts with malformed data. The error indicates that one or more user records in your import file don't meet Firebase's validation requirements. Common issues include missing required fields, invalid field formats, or data type mismatches.

This error occurs when you exceed Firebase Cloud Messaging rate limits for sending messages to topics. Firebase restricts concurrent message fanouts to prevent abuse and ensure fair usage across all projects.

This error occurs when Firebase Cloud Messaging cannot authenticate with Apple Push Notification service because the APNs certificate or authentication key is missing, expired, or invalid.

This Firebase Authentication error occurs when creating or updating users with invalid provider data. Provider data must be a valid array of UserInfo objects with required fields like providerId and uid. Fix by validating your provider data structure before Firebase calls.

This error occurs when a Firebase Storage operation (upload, download, or delete) takes too long and exceeds the maximum retry time limit, typically after 10 minutes of retries due to network issues or large file sizes.

This error occurs when verifying a Firebase session cookie that has been explicitly revoked or invalidated due to account changes. Fix by clearing the invalid cookie and prompting the user to re-authenticate.

This error occurs when Firebase Cloud Messaging rejects a registration token because it is malformed, corrupted, expired, or doesn't match the expected FCM token format. The fix involves validating token generation, ensuring tokens aren't modified during transmission, and removing invalid tokens from your database.

Firebase Analytics limits projects to 500 unique event types. When you exceed this limit, Analytics returns Code 8 and stops logging additional event types. Unlike other errors, this limit is permanent per project and cannot be reset without creating a new Firebase project.

This Firebase Cloud Messaging error occurs when your push notification payload exceeds the 4096-byte (4KB) size limit imposed by Firebase. The error prevents message delivery and requires reducing your payload size by removing unnecessary data, compressing values, or splitting messages.

This Firebase Authentication error occurs when you try to update a user's 'disabled' property with a non-boolean value. The 'disabled' field must be either true or false, and this error appears when passing strings, numbers, null, or undefined instead. The fix involves ensuring you pass a proper boolean value when enabling or disabling user accounts.

This error occurs when Firebase Cloud Messaging detects that a registration token was once valid but has become inactive. The token typically becomes inactive after the app is uninstalled, user data is cleared, the device remains inactive for extended periods, or after a token refresh cycle. Fixing this requires removing stale tokens and implementing proper token lifecycle management.

This error occurs when your Android app's package name doesn't match the one registered in your Firebase project configuration. The mismatch prevents Firebase Cloud Messaging from identifying your app correctly.

This Firebase Cloud Messaging error occurs when a registration token (FCM token) is being used with a different sender ID than the one it was originally created for. The token is permanently tied to its original sender ID and cannot be used with other Firebase projects.

This error occurs when a Firebase session cookie has exceeded its expiration time, requiring the user to re-authenticate. Session cookies can be configured to last between 5 minutes and 2 weeks.

This error occurs when attempting to send a Firebase Cloud Messaging notification without properly specifying the recipient token, topic, or condition. The message cannot be delivered because FCM doesn't know where to send it.

This error occurs when a Firestore transaction runs for more than 270 seconds or remains idle for more than 60 seconds. The transaction fails and no data is written to the database.

This error occurs when you attempt to read a document after performing a write operation within a Firestore transaction, violating the fundamental constraint that all reads must happen before any writes.

Firebase Analytics limits projects to 25 unique user properties. When you attempt to set a 26th property, Analytics returns Code 9 and silently drops the new property without logging it.

The Firebase CLI cannot find emulator configuration in your firebase.json file. This happens when the emulators section is missing or incorrectly formatted, preventing local development.

This error occurs when verifying a Firebase ID token that has been revoked due to account changes like password resets or explicit token revocation. Fix by forcing a token refresh or re-authenticating the user.

This Firebase Cloud Messaging error occurs when the message payload structure is invalid, contains incorrect JSON formatting, uses reserved keywords, or has incompatible field types. The error prevents message delivery until the payload structure is corrected.

This Firebase Storage error occurs when the checksum calculated from the uploaded file on the client side does not match the checksum calculated on the server. This indicates data corruption during transmission, typically caused by network interruptions, memory buffer issues, or file modifications during upload.

This Firebase Hosting error occurs when attempting to deploy a modern web framework (Next.js, Angular, React, etc.) without enabling the experimental webframeworks feature in Firebase CLI. The error prevents deployment of framework-aware hosting configurations that support server-side rendering and other framework-specific features.

This Firebase Authentication error occurs when you attempt to import more than 1,000 users in a single batch operation using the Admin SDK's importUsers() API. Firebase limits each import request to 1,000 users for performance and stability. The solution is to split your user import into smaller batches of 1,000 users or fewer.

This error occurs when custom claim attributes passed to setCustomUserClaims() contain invalid data types or exceed size limits. Fix it by ensuring claims are JSON-serializable and under 1000 bytes.

This HTTP 429 error occurs when you exceed Firebase's API rate limits while deploying Cloud Functions, typically when deploying many functions simultaneously or in rapid succession through CI/CD pipelines.

This error occurs when attempting to access, download, or retrieve metadata for a file that does not exist in Firebase Storage at the given path. The fix involves verifying the file path, ensuring the file was successfully uploaded, and checking Storage security rules.

This error occurs when Firebase Storage cannot find or access the specified bucket, typically because Cloud Storage has not been enabled in the Firebase Console or the bucket name in your configuration is incorrect or missing.

Firebase returns a "functions/not-found" error when a callable function does not exist or has not been deployed. This typically means the function name is mismatched, the function was deleted, or the deployment failed silently.

Firebase has enforced usage quotas on your project that limit authentication operations. Common causes include exceeding daily SMS verification limits, phone authentication requests, or password verification attempts. Resolve by upgrading to Blaze plan, using test phone numbers, or requesting a temporary quota increase.

The Firebase database/unavailable error occurs when your application cannot connect to the Firebase Realtime Database or Firestore service. This is often a transient network issue that can be resolved with proper retry logic and connection verification.

Firebase Cloud Functions exceed their timeout limit when operations take longer than allowed (60 seconds for HTTP functions, 540 for background). Resolve by increasing timeout, optimizing code, or breaking large operations into smaller batches.

Firebase Cloud Functions throws an internal error when your function encounters an unhandled exception, timeout, permission issue, or returns invalid data. This generic error typically indicates a problem in your function code that needs debugging via console logs.

The auth/missing-phone-number error occurs when calling Firebase phone authentication methods without providing a valid phone number. This is thrown when the phone number parameter is missing or not passed to signInWithPhoneNumber or verifyPhoneNumber.

The "auth/user-not-found" error occurs when Firebase cannot locate a user account matching the provided email or identifier. This happens when users attempt to sign in with an unregistered account, incorrect email, or after account deletion.

Firebase rejected your phone number format. Phone numbers must be in E.164 format with country code (e.g., +1 650-555-3434). Fix the format or use a valid test number during development.

The FAILED_PRECONDITION error occurs when a Firestore operation fails because necessary preconditions (like composite indexes or transaction constraints) are not met. Most commonly caused by missing indexes on compound queries combining where() and orderBy().

This error occurs when a user with multi-factor authentication (MFA) enabled tries to sign in. Firebase requires completing the second factor challenge before granting access. Handle this error by catching it and using the MultiFactorResolver to prompt the user for their second factor.

This error occurs when your Firestore security rules deny access to the requested resource. Fix it by reviewing and updating your security rules to allow authenticated users or by ensuring the user is properly logged in before accessing the database.

The functions/permission-denied error occurs when your Cloud Function lacks IAM permissions to access other Firebase services. This is typically caused by missing or insufficient Cloud IAM roles assigned to the service account running your function.

The DEADLINE_EXCEEDED error occurs when a Firestore operation exceeds the default 60-second timeout window. This commonly happens with large batch operations, complex queries, or high-volume read/write operations. Fix it by optimizing queries, breaking operations into smaller chunks, and addressing latency issues.

This error occurs when a user tries to create an account with an email that already exists in your Firebase project. Learn how to detect this error, prompt users to log in instead, and check for existing accounts before sign-up.

The auth/wrong-password error occurs when a user attempts to sign in with an incorrect password for their Firebase account. This common authentication error prevents login and can be resolved by implementing proper error handling, password reset functionality, and validating user input.

Firestore throws this error when your query combines multiple filters or sorting without a pre-built composite index. Create the missing index via the Firebase Console link in the error message or use the Firebase CLI.

The "database/not-found" error occurs when your Firebase Realtime Database configuration is missing, incorrect, or points to a non-existent database. Fix it by ensuring your databaseURL is properly configured in your Firebase initialization code.

Your Cloud Firestore database is in maintenance mode, preventing read/write operations. This typically occurs during initial setup, configuration updates, or Firebase infrastructure maintenance. Wait for the operation to complete or check your database settings.

Firebase internal errors are catch-all exceptions indicating something went wrong on the Firebase server or client-side SDK. This typically requires checking service status, refreshing credentials, or upgrading authentication tiers.

Firebase Remote Config fetch() fails when network is unavailable, caching issues occur, or throttling limits are exceeded. This error prevents your app from retrieving the latest configuration values from Firebase servers.

This error occurs when a user provides an incorrect SMS verification code during Firebase phone authentication. The code may be wrong, expired, or the verification ID may be invalid.

This error occurs when a user tries to sign in with a provider (like Google) using an email already linked to another provider (like Facebook). Enable account linking or prompt users to sign in with their existing provider first.

The auth/user-cancelled error occurs when a user dismisses or cancels a Firebase authentication flow, such as closing a sign-in popup or navigation dialog. While this is intentional user behavior, it needs proper error handling to avoid confusing users with unexpected error messages.

The "database/permission-denied" error occurs when your client lacks authorization to access Firebase Realtime Database. This is commonly due to unauthenticated access, overly restrictive security rules, or authentication state sync issues. Fix it by implementing Firebase Authentication and configuring proper security rules.

The "Caller does not have required role" error occurs when your Firebase project member, service account, or client lacks sufficient IAM permissions or security rule clearance. This is typically resolved by granting the appropriate IAM roles or fixing Firestore security rules.

This error occurs when your code tries to fetch a Firestore document that doesn't exist at the specified path. The fix depends on whether the document should exist or whether you need to handle missing documents gracefully.

The auth/invalid-credential error occurs when your Firebase authentication credential is malformed, expired, or missing required fields like tokens or OAuth credentials. This typically affects OAuth providers, admin SDK operations, and credential linking scenarios.

Firebase blocks your authentication requests due to too many attempts in a short period. This is a rate-limiting protection that requires implementing exponential backoff, adding CAPTCHA verification, or adjusting Firebase quota settings.

The "already-exists" error in Firebase (Firestore) occurs when trying to create a document with an ID that already exists in the database. This validation error prevents accidental overwriting of existing data.

The "aborted" error in Firebase occurs when operations fail due to too much contention on documents in Firestore, insufficient cloud function instances, or network disconnections. Automatic retries typically resolve the issue, but persistent errors require reducing data contention or increasing function capacity.

The auth/invalid-email error occurs when an email address is not properly formatted or contains invalid characters. Fix it by validating and trimming email input before passing it to Firebase authentication methods.

Firebase Realtime Database network errors occur when your app loses connectivity to Firebase servers due to network timeouts, interrupted connections, or unreachable hosts. Reconnect by checking network status, validating authentication tokens, and implementing proper error handling with exponential backoff.

The "auth/operation-not-allowed" error occurs when a sign-in provider is disabled in your Firebase project. Enable the required authentication method in the Firebase console Sign-in Method tab to resolve this issue.

The "PERMISSION_DENIED: User is not authenticated" error occurs when you attempt to access Firestore or Realtime Database without signing in a user first. Firebase security rules require authentication by default, and unauthenticated requests are blocked to protect your data.

The messaging/third-party-auth-error occurs when Firebase Cloud Messaging cannot authenticate with third-party push services like Apple Push Notification service (APNs) or Web Push services. This prevents notifications from being delivered to iOS devices or web browsers.

This error occurs when a user attempts to access or modify files in Firebase Storage without the required permissions. The primary cause is misconfigured Firebase Storage security rules that do not authorize the current user's operation.

The storage/retry-limit-exceeded error occurs when Firebase Storage's automatic retry mechanism reaches its maximum timeout while attempting an upload, download, or delete operation. This typically happens with large files, poor network connectivity, or insufficient timeout configurations.

This error occurs when your Firebase project has reached its storage quota limit and cannot accept new uploads or file operations. Depending on your billing plan, the quota is either 5GB (Spark/free tier) or pay-as-you-go (Blaze plan). You must either delete existing files, upgrade your plan, or request a quota increase.

This error occurs when a Firebase ID token contains invalid claim values, typically a mismatched "aud" (audience) or "iss" (issuer) claim. Fix it by ensuring tokens come from the same Firebase project and that your service account configuration matches your client configuration.

Firebase throws RESOURCE_EXHAUSTED when your project hits quota limits on reads, writes, or storage. Enable billing, optimize your queries to reduce consumption, or request a quota increase from Google Cloud Console.

This error occurs when Firebase services are temporarily unavailable due to scheduled maintenance, unexpected outages, or network connectivity issues. It's typically a transient error that resolves automatically. The fix involves verifying service status, implementing exponential backoff retry logic, checking network connectivity, and disabling/re-enabling the affected service if necessary.

The UNAUTHENTICATED error occurs when Firebase operations are attempted without valid authentication credentials. This commonly happens in Firestore, Realtime Database, and Cloud Functions when users are not signed in or security rules deny unauthenticated access.

The "messaging/mismatched-sender-id" error occurs when the Firebase Cloud Messaging (FCM) Sender ID used by your client app does not match the Sender ID associated with the Firebase project you are using to send messages. This typically happens when registration tokens were generated from a different Firebase project than the one your server is using to send push notifications.

The Firebase "unavailable" error occurs when your application cannot reach the Firebase service backend. This is typically a transient network or service issue that can be resolved with proper error handling, retry logic, and connection verification.

This Firebase Storage error occurs when a file upload or download operation is canceled before completion. The cancellation can be intentional (user clicks cancel button) or unintentional (network loss, app backgrounding, or promise rejection). Understanding when to allow cancellation versus retrying is key to handling this error gracefully.

The "ALREADY_EXISTS" error in Firebase occurs when you attempt to create a resource that has already been created. This can happen across various Firebase services including Firestore, Authentication, Cloud Storage, Cloud Functions, and the Firebase Console itself. The error indicates a conflict with an existing resource.

This error occurs when Firebase Storage cannot locate the Cloud Storage bucket configured in your Firebase app, typically due to a missing, deleted, or incorrectly specified bucket name. It prevents all file upload and download operations.

This error occurs when you exceed Firebase Cloud Messaging (FCM) rate limits while sending messages. Firebase enforces quota token buckets to prevent abuse and ensure fair resource allocation across all projects.

The Firebase Cloud Messaging "messaging/invalid-argument" error occurs when FCM rejects a send request due to invalid parameters, malformed tokens, oversized payloads, or incorrect message structure. This is a critical error that prevents messages from being delivered to devices.

The "not-found" error in Firebase occurs when a requested resource, document, function, or endpoint doesn't exist. This is a common error across Firebase services including Firestore, Cloud Functions, Hosting, and Authentication. The fix depends on which Firebase service is throwing the error and why the resource is missing.

The "INTERNAL: Internal error occurred" error in Firebase indicates a catch-all exception when the SDK encounters an unexpected server or client-side condition. This can arise from network issues, quota limits, SDK version conflicts, or temporary service degradation.

This generic Firebase error occurs across multiple services (Auth, Firestore, Storage, Cloud Functions) when the SDK encounters an unexpected issue that doesn't fit standard error codes. Common causes include network connectivity issues, missing service initialization, quota limits, IAM permission problems, or browser extension conflicts. The fix involves checking detailed error messages in browser console, verifying service status and configuration, and clearing cached data.

This error occurs when Firebase Cloud Messaging attempts to send a message to a registration token that is no longer valid or has been unregistered. The token may have expired due to inactivity, the user may have uninstalled the app, or the app data may have been cleared. The fix involves removing invalid tokens from your database and implementing proper token lifecycle management.

Firebase App Check rejected a request because the reCAPTCHA risk score fell below your configured threshold. This happens when user behavior appears suspicious or bot-like to reCAPTCHA.

Firebase Cloud Storage uses the gs:// protocol for references. This error occurs when you use an incorrect URL format (like HTTP URLs) instead of gs://bucket-name/path. Fix it by using the correct reference method.

The auth/missing-uid error occurs when using the Firebase Admin SDK to perform user operations (like createUser, getUser, updateUser, or setCustomUserClaims) without providing a valid UID parameter. This error indicates that a required user ID identifier is missing or empty.

Firebase Hosting blocks cross-origin requests to Cloud Functions and APIs unless CORS headers are explicitly configured. Enable CORS by setting headers in firebase.json or adding CORS middleware to your Cloud Functions.

Firebase custom claims cannot use OIDC reserved names like "iss", "sub", "aud", "exp", "iat", or Firebase reserved names. This error occurs when you try to set custom user claims with these reserved keywords.

This error occurs when a Firebase Callable Function rejects a request due to missing, invalid, or expired authentication credentials. The client must be signed in with Firebase Authentication, and the ID token must be valid and properly included in the request headers.

You exceeded Firebase Cloud Messaging's per-project rate limit by sending too many messages within a short time window. FCM enforces a default quota of 600,000 messages per minute across your entire project.

This error occurs when you pass invalid parameters to Firebase Authentication methods. Common causes include empty strings, null values, wrong parameter types, or incorrect method syntax. Most fixes involve validating inputs before passing them to Firebase functions.

This Firebase Storage error occurs when you pass an unsupported data type to the upload function. Firebase Storage upload methods accept only Blob, File, Uint8Array, or ArrayBuffer types. Passing strings, objects, or other data types will trigger this validation error. The fix is to ensure your data is converted to one of the supported formats before uploading.

The Firebase Cloud Messaging "messaging/too-many-topics" error occurs when a single app instance (device) attempts to subscribe to more than 2000 topics. Each device has a hard limit of approximately 2000 topic subscriptions to prevent resource exhaustion.

This error occurs when a Cloud Function takes longer to execute than the maximum allowed timeout duration. By default, Firebase sets a 60-second timeout for HTTP functions and 540 seconds for background functions, with higher limits available for 2nd generation functions.

This error indicates that Firebase Cloud Messaging encountered an unexpected condition on the FCM server while processing your request. It's a server-side issue that is typically temporary and should resolve with retries using exponential backoff.

This error occurs when Firebase App Check cannot verify the authenticity of requests to your Firebase services. Token validation failures can stem from misconfigured providers, server time mismatches, expired tokens, or incorrect app registration.

The auth/invalid-page-token error occurs when paginating through Firebase users with an expired or invalid pageToken. Fix it by using tokens immediately after receiving them and always restarting pagination from the beginning if a token expires.

The iOS bundle ID is missing or not properly configured in Firebase. This error occurs when your iOS app's bundle identifier doesn't match what's registered in Firebase Console or when the GoogleService-Info.plist file is missing.

This error occurs when you try to log a Firebase Analytics event with an invalid event name. Firebase enforces strict naming rules to maintain data quality and consistency across your analytics.

Firestore transactions require an active network connection to the backend and will fail immediately when the client is offline. This is by design—transactions need to read and verify data on the server to ensure consistency.

This error indicates your Firebase Cloud Function threw an unhandled exception. It happens when your code crashes without proper error handling, preventing the function from returning a valid response to the client.

This generic Firebase Cloud Messaging error occurs when FCM encounters an unexpected condition that doesn't fit standard error categories. The fix involves validating Firebase setup, checking network connectivity, reviewing message payloads, and implementing robust error logging to identify the root cause.

This error occurs when importing users with a password hash algorithm that Firebase Authentication does not recognize or support. Learn how to identify supported hash algorithms, validate import parameters, and correctly configure user migration.