Supercharge Your Flutter Background Location Tracking with Zero Server Code: Introducing Tracelet Adapters for Supabase & Firebase

If you’ve ever built a ride-sharing, delivery, or fitness app in Flutter, you know the struggle: tracking a user’s location in the background is hard. But what’s even harder is syncing that location data to your server without completely draining the user’s battery.

Today, we’re thrilled to introduce two powerful new additions to the Tracelet ecosystem: tracelet_supabase and tracelet_firebase.

These official adapters allow you to stream background locations directly into your Supabase or Firebase databases natively — with absolutely zero custom server code required.

The Battery Drain Problem

Most Flutter developers approach background location syncing like this:

1. Wake up the app in the background when a new location arrives.
2. Boot up the Dart engine (a heavy process).
3. Use the supabase_flutter or firebase_database SDK to push the data.

While this works, it devours battery life. Waking up the Dart isolate hundreds of times an hour to perform simple network requests is wildly inefficient.

The Tracelet Solution

Tracelet solves this by keeping the Dart isolate asleep. Its HTTP Sync Engine is written natively in Kotlin (Android) and Swift (iOS).

With our new adapters, you can configure Tracelet’s native engine to push locations directly to the Supabase PostgREST API or Firebase RTDB REST API. It completely bypasses Dart, making your app incredibly battery-efficient. Even better, both adapters automatically handle background authentication token refreshes so your uploads never fail due to expired JWTs!

Let’s look at how easy it is to integrate both.

⚡️ Supabase Integration (tracelet_supabase)

The tracelet_supabase adapter provides a zero-configuration integration with your Supabase database.

Direct Database Integration

When you configure the adapter, Tracelet natively authenticates and pushes batches of location data directly to a Postgres RPC function in your Supabase backend.

import 'package:supabase_flutter/supabase_flutter.dart';
import 'package:tracelet/tracelet.dart';
import 'package:tracelet_supabase/tracelet_supabase.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();

  // 1. Initialize Supabase
  await Supabase.initialize(
    url: 'https://xyz.supabase.co',
    anonKey: 'YOUR_ANON_KEY',
  );

  // 2. Configure Token Refresh (Crucial for background tracking!)
  await TraceletSupabase.configureTokenRefresh(anonKey: 'YOUR_ANON_KEY');

  // 3. Build the Native HTTP Config
  final httpConfig = TraceletSupabase.buildHttpConfig(
    supabaseUrl: 'https://xyz.supabase.co',
    anonKey: 'YOUR_ANON_KEY',
    tableName: 'locations', 
  );

  // 4. Initialize Tracelet
  await Tracelet.ready(Config(
    distanceFilter: 50,
    http: httpConfig,
  ));

  runApp(MyApp());
}

It also supports routing your locations through Supabase Edge Functions if you need server-side validation or geocoding before inserting into Postgres!

🔥 Firebase Integration (tracelet_firebase)

If you are heavily invested in the Firebase ecosystem, the tracelet_firebase adapter allows you to bypass expensive Cloud Functions. It pushes locations directly to the Firebase Realtime Database (RTDB) via its REST API.

This means you achieve 100% serverless, zero-cost (free tier) background location tracking.

import 'package:tracelet_firebase/tracelet_firebase.dart';
import 'package:firebase_auth/firebase_auth.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  await Firebase.initializeApp();

  // 1. Configure the auto-token refresher
  await TraceletFirebase.configureTokenRefresh();

  // 2. Build the HTTP Config pointing to your RTDB
  final user = FirebaseAuth.instance.currentUser;
  if (user != null) {
    final httpConfig = await TraceletFirebase.buildHttpConfig(
      databaseUrl: 'https://your-project-default-rtdb.firebaseio.com',
      path: 'locations/${user.uid}', // Secure this path in your RTDB rules
    );

    // 3. Start Tracelet
    await Tracelet.ready(Config(
      http: httpConfig,
    ));
  }
}

By setting up standard Firebase Security Rules, you can ensure users only write to their own location paths securely.

Conclusion

Tracking and syncing background locations shouldn’t mean sacrificing your users’ battery life or writing complicated middle-tier cloud functions. With tracelet_supabase and tracelet_firebase, you get enterprise-grade, native-level syncing right out of the box.

Check out the packages on pub.dev today to supercharge your app’s location capabilities!

• tracelet_supabase on pub.dev
• tracelet_firebase on pub.dev