The SDK
2 lines of code open a new revenue line.
One SDK for Android and iOS. It wakes up only when your app already holds Bluetooth® and location grants, scans for sensor beacons, stamps them with a fresh GPS fix, and forwards them. Your org earns a bounty for every device your installs hear first each day, paid in Lightning sats.
Apache-2.0 · Zero dependencies · Android minSdk 26 · iOS 15+
The whole integration.
From your existing service on Android:
EEGateway.configure(context, EEConfig.GatewayToken(tokenFromYourBackend)) EEGateway.start()
And the Swift twin on iOS:
EEGateway.configure(.gatewayToken(token: tokenFromYourBackend)) EEGateway.start()
No signup screens, no new permission prompts, no EE credential in your binary. Your app keeps owning the user experience; the SDK does its work underneath it.
The contract.
An SDK lives inside someone else's app, so it has to behave like a guest. These rules are frozen API, not aspirations.
It never prompts.
start() without the grants parks in its awaiting-permissions state and advances on its own the moment your permission flow completes. Revoke a grant mid-run and it parks again. Your users never see a dialog they didn't expect.
It never throws.
No exception, no crash vector, no force-unwraps. If something goes wrong on our side, your app never finds out the hard way.
Your lifecycle drives it.
The SDK starts no services and declares no background modes of its own. It rides the foreground service or background mode your app already runs for its real features.
There's a kill switch.
Flip one flag on our side and every install pauses its pipeline on the next heartbeat, no app update required. Flip it back and they resume. You can leave any time.
Zero dependencies.
The Android AAR pulls in nothing beyond the Kotlin stdlib you already ship. The Swift package imports Foundation and the system frameworks, nothing else. Your dependency audit stays boring.
Apache-2.0.
Use it in a proprietary app with no strings attached. Read every line before you ship it; we'd do the same.
Provisioning at fleet scale.
Your backend holds one org key and mints a gateway identity per install through the org API:
POST /api/v1/org/gateways
Authorization: Bearer ee_org_…
{ "name": "install-8f3a" }
→ { "gateway": { … }, "token": { "key": "ee_live_…" } }
The org key stays on your servers; each device gets its own revocable ee_live_ token over your authenticated channel. Tokens are verified against the server before they're persisted and encrypted at rest, so a revoked or mistyped token can't poison a phone. There's also a self-mint demo mode for kicking the tires before you wire up the backend.
What your users will ask, answered.
The packets your app relays are encrypted by the device owner's key before your app ever hears them. Neither you nor we can read the payload, and the tracked devices rotate their broadcast identifiers at least every 24 hours. The location stamps your installs attach pay bounties and draw the coverage map; they're never sold and never used for ads. The legal page spells out exactly what we store and share.
Battery cost stays small by construction. The scan filters on a single service ID, which lets the OS coalesce it cheaply, and uploads go out in batches that skip empty queues. The only always-on traffic is a small heartbeat every 3 minutes, which is also how the kill switch reaches every install.
For the store reviews, the SDK ships with the compliance homework done: drop-in user-disclosure copy, plus the exact wording for Google Play's data safety form and Apple's privacy labels, all in the repo's compliance guide. Disclosure and consent are what separated the SDKs that lasted from the ones that got their hosts banned, so we treat them as part of the product.
Get it.
Both SDKs are open source on GitHub, tagged 0.1.1 under Apache-2.0. On iOS, add the package in Xcode: File → Add Package Dependencies → paste the repo URL, rule Up to Next Minor. On Android, vendor the :sdk module from source at the tag; the integration guide in the repo covers both paths. The iOS build has already run end to end against production; the Android build ships with a 173-test harness and the same wire contracts.
The economics start with a conversation: tell us what you've built and roughly how many installs carry it, and we'll walk you through the math for your fleet, on terms that reward being early.