0.1.1Native location SDK · iOS, Android, Flutter & React Native

Background location
that actually stays on

Beekon is a small, focused SDK for capturing where your users go — in the foreground, in the background, and after the app has been swiped away. It runs on the device, keeps a rolling history, and respects the battery. No servers to wire up. No surprises in production.

Get a license View the docs
3
AccuracyMode values — low-power passive to GPS-grade foreground tracking
7d
of location history kept on the device, ready to read at any time
4
platforms covered: Android, iOS, Flutter, and React Native
Built on the platforms you already trust
FusedLocation
CoreLocation
pub.dev
npm
Maven Central
SPM
01 · Platforms

One SDK.
Every platform you ship on.

We build the Android and iOS libraries ourselves, in their native languages. Flutter and React Native get the same SDK through a thin language wrapper — same behaviour, same battery, same history. Pick whichever stack your team is on; we keep them in step.

Available
Android
Kotlin library · Android 8 and up
Available now
Available
iOS
Swift library · iOS 13 and up
Available now
Available
Flutter
Dart plugin · wraps both natives
Available now
Available
React Native
TypeScript module · wraps both natives
Available now
02 · Integration

Configure.
Start. Listen.

The shape of the API is the same on every platform: one config object, one start call, and a stream of locations to listen to. The naming follows whatever feels natural in your language — Kotlin Flow on Android, AsyncStream on iOS, Streams in Dart, event listeners in TypeScript. Nothing exotic to learn.

import `in`.wayq.beekon.Beekon
import `in`.wayq.beekon.BeekonConfig
 
// Optional — defaults are a 30s / 100m gate plus an auto-resolved notification.
Beekon.configure(
  BeekonConfig.SelfManaged(
    minTimeBetweenLocationsSeconds = 30,
    minDistanceBetweenLocationsMeters = 100.0,
    accuracyMode = AccuracyMode.Balanced,
    whenStationary = StationaryMode.Pause,
  ),
)
 
Beekon.start() // suspends until the foreground service is running
 
// Stream gated locations on the caller's scope.
Beekon.locations
  .onEach { fix -> render(fix) }
  .launchIn(scope)
in.wayq.beekon · MainActivity.kt
03 · Battery

Three accuracy modes.
Honest battery numbers.

Set accuracyMode to low, balanced, or high in BeekonConfig — that single field controls how the OS selects fixes, how often they arrive, and how much battery they cost. The numbers below are measured on real phones running real builds, not estimated.

Distance between fixes
100m
Update interval
30s
Battery / hour
5–10%
Use case
City-block accuracy at moderate battery cost.
Battery draw1h sustained
0%5–10% on Pixel 8 · iPhone 15 Pro30%
04 · What makes it different

Three things we
refuse to compromise on.

Most location SDKs cut a corner somewhere — a shared core that pretends to be native, a smoothing layer that hides what the phone actually saw, or a server you didn’t ask to depend on. Beekon doesn’t. These are the choices that make continuous tracking actually work in the wild.

01
Built natively. No shared core.
Each platform gets a real native library, written in its own language. We don’t squeeze a shared C engine into both — location is too tied to the operating system for that to work well. Instead, the two libraries expose the same API, behave the same way, and are tested side-by-side.
Kotlin for AndroidSwift for iOS
02
What the OS sees, you see.
The phone’s own location service already does the heavy lifting — fusing GPS, Wi-Fi, sensors, and motion. We don’t second-guess it with our own filters or smoothing layers. You get accurate, faithful points, not numbers we’ve massaged in the middle.
No mystery filteringFaithful to the source
03
History stays on the device.
Every point goes into a local database that lives inside the SDK. In self-managed mode, nothing is sent to our servers. Your app reads history when it needs to — even when the user has been offline for days. We keep the last seven days by default, and prune older points automatically.
Local storageRead history any time
05 · Pricing

License what
you actually ship.

Free for indie and open-source teams. Everyone else buys a one-time license per app — no subscription. Each license covers one app and unlimited builds, with a year of updates and priority support. Bundle two or more and the price drops automatically.

Indie & open source
Free
$0
  • Every feature, including geofencing
  • For teams under $1M revenue and 100 people
  • Or any open-source app (PolyForm SBL)
  • No card required
Source-available · soft, never-blocking enforcement
Pro · one-time per-app license
Android + iOS · 2 licenses · bundle saves $60
$538 one-time
Continue to checkout
Pro
$299 per app, one-time
  • One production app per license
  • $299 native (iOS/Android) · $499 wrapper (Flutter/RN)
  • 1 year of updates · priority support
  • Ships forever · renew at $99/yr for new versions
For teams past the free threshold
Enterprise
Custom
Let's talk
  • Unlimited apps and bundle IDs
  • Source escrow and security review
  • Dedicated Slack · 4h response · NDA
  • Custom test routes · roadmap input
  • White-label and OEM redistribution
For OEMs, fleets, and platforms
06 · Questions

Asked, often.

The questions we get most often — and a few you should ask before picking any location SDK. If something here doesn’t match what you need, the Enterprise tier is where we get into the details.

A one-time payment for one production app on one platform: unlimited builds, one year of updates, and priority support. The app you ship never stops working. Renewals are $99/yr and only buy access to new versions — they’re optional. If you need more than one app or want to redistribute the SDK, talk to us about Enterprise.
Yes, for indie and open-source teams. If your company makes under $1M a year and has fewer than 100 people, or your app is open source, the full SDK — including geofencing — is free under the PolyForm Small Business License. No card required. The Pro license is for everyone above that threshold.
Because location is an operating-system feature, not a math problem. Each platform has its own background rules, permission model, and battery behaviour — and getting them right means writing native code, not wrapping a shared C library and hoping. Both libraries follow the same written contract, so behaviour stays consistent across platforms.
Yes. On Android we use a foreground service so the system keeps us alive even under battery-saver and aggressive OEM behaviour. On iOS we use the platform’s background location mode plus the system wake-up that fires when the user moves a meaningful distance — the same approach Apple’s own apps use.
On the device, in a local database that ships inside the SDK. In self-managed mode, nothing is sent to our servers. Your app reads history when it needs to. By default we keep the last seven days; older points are pruned automatically.
No. The phone’s own location service already does that work, and it has access to sensors and GPS we don’t. We pass its output through to your app, applying only the distance and interval rules you configure. What the OS sees is what you get.
Yes. The development build is fully functional and free to use — it just prints a small notice in your logs. A paid license removes the notice and lets you ship to production.