How to fix storage/invalid-checksum: Client and server file checksums don't match in Firebase

// Web SDK example with retry logic
import { ref, uploadBytes } from 'firebase/storage';

async function uploadWithRetry(storage, filePath, file, maxRetries = 3) {
  let lastError;

  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      const storageRef = ref(storage, filePath);
      const result = await uploadBytes(storageRef, file);
      console.log('Upload successful on attempt', attempt);
      return result;
    } catch (error) {
      lastError = error;

      if (error.code === 'storage/invalid-checksum') {
        console.log(`Checksum error on attempt ${attempt}/${maxRetries}`);

        if (attempt < maxRetries) {
          // Exponential backoff: 1s, 2s, 4s
          const delay = Math.pow(2, attempt - 1) * 1000;
          console.log(`Retrying in ${delay}ms...`);
          await new Promise(resolve => setTimeout(resolve, delay));
        }
      } else {
        // Non-checksum error, don't retry
        throw error;
      }
    }
  }

  throw lastError;
}

// Usage
try {
  await uploadWithRetry(storage, 'uploads/myfile.pdf', fileBlob);
} catch (error) {
  console.error('Upload failed after all retries:', error);
}

// Web SDK - Resumable upload with pause/resume capability
import { ref, uploadBytesResumable } from 'firebase/storage';

function uploadLargeFile(storage, filePath, file) {
  const storageRef = ref(storage, filePath);
  const uploadTask = uploadBytesResumable(storageRef, file);

  return new Promise((resolve, reject) => {
    uploadTask.on('state_changed',
      // Progress observer
      (snapshot) => {
        const progress = (snapshot.bytesTransferred / snapshot.totalBytes) * 100;
        console.log('Upload is ' + progress + '% done');

        // Check state
        switch (snapshot.state) {
          case 'paused':
            console.log('Upload is paused');
            break;
          case 'running':
            console.log('Upload is running');
            break;
        }
      },
      // Error observer
      (error) => {
        if (error.code === 'storage/invalid-checksum') {
          console.error('Checksum mismatch - retrying upload');
          // Can retry from here
        }
        reject(error);
      },
      // Success observer
      () => {
        console.log('Upload completed successfully');
        resolve(uploadTask.snapshot);
      }
    );
  });
}

// Usage
try {
  await uploadLargeFile(storage, 'uploads/large-file.mp4', videoFile);
} catch (error) {
  console.error('Upload failed:', error);
}

// Create immutable copy of file before upload
async function uploadImmutableFile(storage, filePath, file) {
  // For File objects (from input), create a Blob copy
  const immutableBlob = file.slice(0, file.size, file.type);

  // Store original file size for verification
  const originalSize = file.size;

  console.log('Uploading file:', {
    name: file.name,
    size: originalSize,
    type: file.type
  });

  const storageRef = ref(storage, filePath);

  try {
    const result = await uploadBytes(storageRef, immutableBlob);
    return result;
  } catch (error) {
    if (error.code === 'storage/invalid-checksum') {
      console.error('Checksum error - file may have been modified');
      console.error('Original size:', originalSize);
      console.error('Current size:', file.size);
    }
    throw error;
  }
}

// For Node.js environment - read file once into buffer
const fs = require('fs');
const { getStorage, ref, uploadBytes } = require('firebase-admin/storage');

async function uploadFileFromDisk(filePath, storagePath) {
  // Read entire file into memory at once
  const fileBuffer = fs.readFileSync(filePath);

  const storage = getStorage();
  const storageRef = ref(storage, storagePath);

  // Upload from buffer (immutable)
  await uploadBytes(storageRef, fileBuffer);
}

# For web projects
npm update firebase

# Check current version
npm list firebase

# Or update to specific latest version
npm install firebase@latest

# For React Native
npm update @react-native-firebase/storage

# For Flutter
flutter pub upgrade firebase_storage

// Check Firebase SDK version
import { SDK_VERSION } from 'firebase/app';
console.log('Firebase SDK version:', SDK_VERSION);

// For Admin SDK
const admin = require('firebase-admin');
console.log('Admin SDK version:', admin.SDK_VERSION);

// For Node.js Admin SDK - configure request options
const admin = require('firebase-admin');

admin.initializeApp({
  credential: admin.credential.applicationDefault(),
  storageBucket: 'your-project.appspot.com'
});

// When uploading, configure timeout and size limits
const bucket = admin.storage().bucket();
const file = bucket.file('uploads/large-file.mp4');

const options = {
  // Increase timeout for large files
  timeout: 300000, // 5 minutes

  // Configure resumable upload threshold
  resumable: true,

  // Metadata
  metadata: {
    contentType: 'video/mp4',
    cacheControl: 'public, max-age=31536000',
  }
};

await bucket.upload('/path/to/local/file.mp4', options);

// For ESP32 or embedded systems
// Adjust buffer size in config (C++ example)
/*
config.fcs.upload_buffer_size = 2048; // Smaller chunks for limited memory
config.timeout.serverResponse = 60 * 1000; // 60 second timeout
*/

// Manual chunking for files > 2GB
async function uploadInChunks(storage, filePath, file, chunkSize = 50 * 1024 * 1024) {
  if (file.size <= chunkSize) {
    // Upload normally for small files
    return await uploadBytes(ref(storage, filePath), file);
  }

  console.log(`File size: ${file.size} bytes, splitting into chunks`);

  // For files > 2GB, use multipart upload
  // Note: Firebase Storage has 5TB max file size
  const storageRef = ref(storage, filePath);
  const uploadTask = uploadBytesResumable(storageRef, file);

  return uploadTask;
}

// Monitor network status during upload
function monitorNetworkDuringUpload(uploadTask) {
  // Check if online
  if (!navigator.onLine) {
    console.warn('Browser is offline');
    uploadTask.pause();
    return;
  }

  // Listen for network changes
  window.addEventListener('online', () => {
    console.log('Connection restored, resuming upload');
    uploadTask.resume();
  });

  window.addEventListener('offline', () => {
    console.log('Connection lost, pausing upload');
    uploadTask.pause();
  });

  // Monitor connection quality (if available)
  if ('connection' in navigator) {
    const connection = navigator.connection;
    console.log('Connection type:', connection.effectiveType);
    console.log('Downlink speed:', connection.downlink, 'Mbps');

    connection.addEventListener('change', () => {
      console.log('Connection changed to:', connection.effectiveType);

      // Pause uploads on slow connections
      if (connection.effectiveType === 'slow-2g' || connection.effectiveType === '2g') {
        console.warn('Slow connection detected');
        uploadTask.pause();
      }
    });
  }
}

// Usage with resumable upload
const uploadTask = uploadBytesResumable(storageRef, file);
monitorNetworkDuringUpload(uploadTask);

# Check network stability (Linux/Mac)
ping -c 10 firebasestorage.googleapis.com

# Check for packet loss
# Look for "packet loss" percentage in output

# Test bandwidth
curl -w "@curl-format.txt" -o /dev/null -s https://firebasestorage.googleapis.com