Google Firebase SDKs & Libraries: Installation & Quickstarts (2026)

SDKs overview

Google Firebase provides a suite of Software Development Kits (SDKs) and client libraries designed to facilitate interaction with its backend services across various platforms. These SDKs abstract much of the complexity of direct API calls, offering idiomatic interfaces for common programming languages and environments. Functionality includes user authentication, real-time data synchronization with Cloud Firestore and Realtime Database, secure file storage with Cloud Storage, and event-driven backend code execution with Cloud Functions for Firebase. The availability of official SDKs for both client-side and server-side environments allows developers to build full-stack applications with Firebase as the primary backend.

The Firebase SDKs are developed and maintained by Google, ensuring compatibility and integration with the Firebase platform. They often include modular components, allowing developers to import only the necessary services, reducing application footprint. For instance, a mobile application focused solely on authentication and a real-time database would only include those specific SDK modules, rather than the entire Firebase suite. The comprehensive Firebase documentation provides detailed guides for integrating and using these SDKs across all supported platforms, including quickstarts and API references for each service.

Official SDKs by language

Firebase offers official SDKs for a broad range of programming languages and platforms, catering to mobile, web, and backend development needs. Each SDK is tailored to the specific platform's conventions and best practices, providing a native development experience. The following table outlines the key official SDKs, their primary package managers, and typical installation commands.

Installation

Installation methods for Firebase SDKs vary by platform and language. Typically, client-side SDKs for mobile and web applications are integrated using platform-specific package managers or direct downloads, while server-side SDKs (Admin SDKs) are installed via language-specific package managers.

Web (JavaScript)

For web applications, the Firebase SDK can be installed via npm for module bundlers or included directly via a Content Delivery Network (CDN) for simpler projects. Initializing Firebase in a web application typically involves configuring the SDK with your Firebase project credentials, which can be found in the Firebase console project settings. The Firebase Web SDK documentation provides detailed installation steps for various frameworks and setup preferences.

# Using npm
npm install firebase

// Example initialization in JavaScript
import { initializeApp } from 'firebase/app';
import { getAnalytics } from "firebase/analytics";

const firebaseConfig = {
  apiKey: "YOUR_API_KEY",
  authDomain: "YOUR_AUTH_DOMAIN",
  projectId: "YOUR_PROJECT_ID",
  storageBucket: "YOUR_STORAGE_BUCKET",
  messagingSenderId: "YOUR_MESSAGING_SENDER_ID",
  appId: "YOUR_APP_ID",
  measurementId: "YOUR_MEASUREMENT_ID"
};

// Initialize Firebase
const app = initializeApp(firebaseConfig);
const analytics = getAnalytics(app);

Android (Kotlin / Java)

Android applications integrate Firebase SDKs by declaring dependencies in the module-level build.gradle file. Google Play services must be available on the device for many Firebase features to function correctly. The Firebase Android SDK setup guide details the process of adding the Google Services plugin and declaring the Firebase Bill of Materials (BOM) to manage library versions.

// In your app-level build.gradle file
dependencies {
    // Import the Firebase BoM
    implementation(platform('com.google.firebase:firebase-bom:32.7.0'))

    // Add the dependencies for the desired Firebase products
    // For example, Firebase Authentication and Cloud Firestore
    implementation 'com.google.firebase:firebase-auth-ktx'
    implementation 'com.google.firebase:firebase-firestore-ktx'
}

iOS (Swift / Objective-C)

For iOS projects, Firebase SDKs are typically integrated using CocoaPods or Swift Package Manager. After installation, a GoogleService-Info.plist file must be added to the Xcode project and referenced in the application delegate. The official Firebase iOS setup documentation provides comprehensive instructions for integrating Firebase with both Swift and Objective-C projects.

# Using CocoaPods
pod 'Firebase/Auth'
pod 'Firebase/Firestore'

// Example initialization in Swift (AppDelegate.swift)
import FirebaseCore
import FirebaseFirestore

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {

  func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
    FirebaseApp.configure()
    return true
  }
}

Admin SDKs (Node.js, Python, Go, Java, C++)

Firebase Admin SDKs are used for privileged environments, such as servers or backend services, to interact with Firebase. They grant full read/write access to your Firebase project's resources and can perform operations like user management, custom token minting, and programmatic access to Cloud Firestore and Realtime Database. Installation typically involves language-specific package managers, and authentication is handled using a service account key file. The Firebase Admin SDK documentation offers specific instructions for each supported language, including secure credential management.

# Node.js Admin SDK
npm install firebase-admin

# Python Admin SDK
pip install firebase-admin

Quickstart example

This quickstart demonstrates adding a new document to a Cloud Firestore database using the Firebase Web SDK. This example assumes you have an initialized Firebase project and the Firebase SDK installed and configured as shown in the installation section.

import { initializeApp } from 'firebase/app';
import { getFirestore, collection, addDoc } from 'firebase/firestore';

// Your web app's Firebase configuration
const firebaseConfig = {
  apiKey: "YOUR_API_KEY",
  authDomain: "YOUR_AUTH_DOMAIN",
  projectId: "YOUR_PROJECT_ID",
  storageBucket: "YOUR_STORAGE_BUCKET",
  messagingSenderId: "YOUR_MESSAGING_SENDER_ID",
  appId: "YOUR_APP_ID"
};

// Initialize Firebase
const app = initializeApp(firebaseConfig);
const db = getFirestore(app);

async function addCity() {
  try {
    const docRef = await addDoc(collection(db, "cities"), {
      name: "Los Angeles",
      state: "CA",
      country: "USA",
      population: 3792621,
      capital: false
    });
    console.log("Document written with ID: ", docRef.id);
  } catch (e) {
    console.error("Error adding document: ", e);
  }
}

addCity();

This JavaScript code snippet initializes Firebase, gets a reference to Cloud Firestore, and then calls the addDoc function to create a new document in a collection named cities. The addDoc function automatically generates a unique ID for the new document and returns a DocumentReference. For more detailed examples across various Firebase services and languages, refer to the official Firebase samples documentation.

Community libraries

Beyond the official Google-maintained SDKs, the Firebase ecosystem benefits from a vibrant community that develops and maintains additional libraries and tools. These community-driven projects can extend Firebase's functionality, provide integrations with other platforms, or offer alternative API wrappers. While not officially supported by Google, these libraries can be valuable for specific use cases. Developers should review the stability, maintenance, and license of any community library before integrating it into a production application.

Examples of community contributions often include:

• Framework-specific integrations: Libraries that simplify integrating Firebase with popular front-end frameworks like React, Vue, or Angular, often providing hooks, components, or services tailored to those frameworks. For instance, ReactFire is a popular community library for React applications that provides hooks to interact with Firebase.
• Desktop application support: While Firebase offers official SDKs for C++ and Unity, community efforts might extend support or simplify integration for other desktop environments or frameworks not directly covered by Google.
• GraphQL layers: Some community projects provide GraphQL interfaces to Firebase services, allowing developers to query and mutate data using GraphQL syntax rather than direct SDK calls. This can be particularly useful for projects already leveraging GraphQL.
• Utility functions and helpers: Smaller libraries that offer helpful utilities, such as simplified error handling for Firebase operations, advanced data manipulation for Firestore results, or specific authentication flows.

When considering a community library, it is advisable to check its GitHub repository for active development, issue resolution, and community engagement. The Firebase documentation often spotlights notable community projects that gain significant traction and usefulness.