●  New: build your backend and app together with AI. Point Claude or Cursor at AppAmbit over MCP.

On mobile?

Email yourself the setup link so you can finish when you're at your computer.

Android · Kotlin & Java

One line in onCreate. Your app starts reporting.

Add one dependency from Maven Central and one AppAmbit.start() call, and your Android app begins tracking sessions, device details and crashes on its own. When the phone loses signal it keeps everything on disk and sends it in batches later.

Start free See the setup
Maven Central Open source API 21+

No credit card required. Free tier available. The same SDK also gives you a database, cloud functions and remote config.

MainActivity.kt · Kotlin Live 
import com.appambit.sdk.AppAmbit
 
class MainActivity : AppCompatActivity() {
    override fun onCreate(state: Bundle?) {
        super.onCreate(state)
 
        // the whole integration
                                AppAmbit.start(applicationContext, "<YOUR-APPKEY>")
    }
}
Sessions, device details and crashes start from that call. com.appambit:appambit:1.2.1
One

Line in onCreate. That is the whole integration.

21

Minimum API level. Android 5.0 and up.

2

Languages, one artifact. Kotlin and Java.

0%

No data lost. It queues and sends later.

The whole API

Small enough to learn in one sitting.

Beyond the start call there is very little to remember. These are the calls you will actually use, and each one reads the same from Kotlin and from Java.

AppAmbit.start(context, key)

The one you always write

Called in onCreate with your App Key. Everything else on this page keys off it, in Kotlin and in Java alike.

Analytics.trackEvent(name, props)

Track what matters

Send a named event with a map of string properties. Everything else about the session is already attached for you.

Crashes.logError(exception)

Report a handled error

Catch an exception, log it, and carry on. The error lands beside your crashes with the same session context.

Crash monitoring

Crashes.logError(exception, props)

Attach your own properties

Pass a map of strings beside the exception and it travels with the log, so the report carries the order id or the plan the person was on.

Crashes.generateTestCrash()

Prove it works

Fire a deliberate crash so you can watch a real report arrive before you ship anything to users.

Analytics.enableManualSession()

Take over sessions

Automatic sessions are the default. Turn them off and start and end them yourself when your app needs that control.

Get an App Key

That is the whole surface. The key that makes those calls report takes a minute to create.

Same artifact

You came for crashes. You get a backend.

The dependency you already added covers more than reporting. When you need a table, an endpoint or a flag, it is the same SDK and the same App Key, with nothing new to install.

App Analytics

Sessions, devices and Android versions, drawn from what the SDK already sends the moment it starts.

App Analytics

Event Tracking

The events you name yourself, with their properties kept on every occurrence and grouped in the dashboard.

Event Tracking

Session Timeline

Every crash arrives inside the session it happened in, next to the events and logs that came before it.

Session Timeline

Breadcrumbs

The trail of steps that led to the crash, so you are reading a path rather than guessing one.

Breadcrumbs

Remote config

Flip a flag or change a value and your app picks it up, with no rebuild and no trip through Play Store review.

Remote config

App Database

Real SQL from your Android app through AppAmbitDb, with no server to run and no connection string in your code.

App Database

Cloud Code

Call a Node.js function you deployed inside AppAmbit with CloudCode.call, straight from Kotlin or Java.

Cloud Code

Content management

Read published content types and entries from the SDK, so copy and screens can change without a release.

CMS guide

Push notifications

Add the push artifact, call PushNotifications.start() after AppAmbit.start(), and send from your dashboard.

Push notifications

Build delivery

Hand an APK or an AAB to your testers over a link, and see who is running which one.

Build delivery

AI Agent over MCP

Point Claude or Cursor at AppAmbit over MCP and let it read your crashes and sessions, or set the backend up for you.

AI Agent

AI App Builder

Ask Claude or Cursor for a feature and let it provision the backend that feature needs, on this same account.

AI App Builder
Open an account

Everything on this row is included, on the same App Key and the same free tier.

Built for real phones

A tunnel should not cost you a crash report.

Android devices lose signal constantly, and that is often exactly when the interesting crashes happen. The SDK writes sessions, events, logs and crashes to local storage the moment the network drops, watches for connectivity to come back, and then sends everything at once in batches. You configure nothing.

On the device offline
Session1
Events7
Handled errors2
Crash1

Written to local storage. Nothing is dropped while the phone is out of range.

queued
In your dashboard waiting
Session0
Events0
Handled errors0
Crash0

Everything arrives together the moment the device is back, batched into few requests.

See a session timeline

The queue empties when the network comes back, and the session reads the same either way.

Build delivery

Your APK in a tester's hands the minute CI is green.

Connect the repository once and every successful build lands in AppAmbit with its branch, commit, author and workflow link attached. Send it to your testers from there, and they install it from a page instead of hunting for an artifact.

.apk .aab Build delivery

GitHub Actions

Build your APK or AAB in a workflow and let the signed webhook hand it straight to AppAmbit.

Bitbucket Pipelines

Wire a pipeline step to publish each build, with the branch, commit and author carried along.

Azure DevOps

Connect an Azure pipeline and every green build shows up ready to send to your testers.

Distribute your first build

Connect the repository, and testers install from a link instead of waiting on a store.

Setup

Three steps, and you are reporting.

Create your app in the dashboard to get an App Key, then touch three files in Android Studio. There is no wrapper to write and no build plugin to install.

01

Add the dependency

One line from Maven Central, then a Gradle sync. The version below is the one published right now.

app/build.gradle.kts app/build.gradle 
dependencies {
                                implementation("com.appambit:appambit:1.2.1")
                            }
dependencies {
                                implementation 'com.appambit:appambit:1.2.1'
                            }
02

Grant two permissions

The SDK needs to reach the network, and to notice when the connection comes back so it can send what queued up. Same in either language.

AndroidManifest.xml 
<uses-permission android:name="android.permission.INTERNET" />
                    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
03

Start it in onCreate

One call in your main Activity, with the App Key from your app's Info page. Sessions, device information and crash reporting begin from there.

MainActivity.kt MainActivity.java 
override fun onCreate(state: Bundle?) {
                                super.onCreate(state)
                                AppAmbit.start(applicationContext, "<YOUR-APPKEY>")
                            }
@Override
                            protected void onCreate(Bundle state) {
                                super.onCreate(state);
                                AppAmbit.start(getApplicationContext(), "<YOUR-APPKEY>");
                            }

Run a Gradle sync after adding the dependency. The full walkthrough, including the push notification setup, is in the getting started guide.

Create your App Key

Step one is a free account. The other two take about five minutes.

Push notifications

One more dependency, not another vendor.

Push runs on the same App Key and the same install. You bring a Firebase project for delivery, AppAmbit keeps the device tokens, and you send from the dashboard or from a Cloud Code function.

Add the appambit-push-notifications artifact next to the core one, with the Firebase BOM so the Firebase versions stay aligned.
Drop in google-services.json and apply the Google Services plugin. That is the Firebase side of the setup, and the only part that leaves AppAmbit.
Ask for the permission on Android 13 and up, where a notification without POST_NOTIFICATIONS never reaches the tray.
How push notifications work
Starting push · Kotlin 
import com.appambit.sdk.PushNotifications
                         
                        // in onCreate, after AppAmbit.start(...)
                        PushNotifications.start(applicationContext)
                         
                        // so a tap opens the right screen, cold start included
                        PushNotifications.handleNotificationOpened(this, intent)
                         
                        // Android 13 and up
                        PushNotifications.requestNotificationPermission(this)
Java is the same four calls, with getApplicationContext().
Set up push

Your own credentials, the tokens already tied to your App Key, and no second vendor to sign with.

Questions

Android, answered.

Does AppAmbit support both Kotlin and Java?
Yes, and there is only one artifact for both. AppAmbit.start(), Analytics.trackEvent() and Crashes.logError() are called the same way from either language, and every snippet in the documentation is shown in Kotlin and in Java.
How much code do I actually have to write?
One dependency in app/build.gradle, the INTERNET and ACCESS_NETWORK_STATE permissions in AndroidManifest.xml, and one AppAmbit.start() call in onCreate. Sessions, device information and crash reporting begin on their own from there.
What happens when the device has no connection?
Nothing is lost. Sessions, events, logs and crashes are written to local storage while the device is offline. The SDK watches connectivity and sends everything that queued up in batches once it returns. It is built in and needs no configuration.
Does it work with Jetpack Compose?
Yes. The SDK is a plain Android library started from onCreate, so it does not care whether your screens are Compose or Views. You call the same trackEvent and logError APIs from either one.
What if I minify with ProGuard or R8?
Minification stays yours to configure. If you obfuscate your release build, add the ProGuard rules your setup needs for the SDK. The getting started guide covers where that fits into your Gradle configuration.
What is the minimum Android version?
Android 5.0, API level 21, and up. The SDK is built with Gradle and published on Maven Central as com.appambit:appambit, and the source is on GitHub.
Can I add push notifications too?
Yes. Add the com.appambit:appambit-push-notifications artifact next to the core SDK and call PushNotifications.start() after AppAmbit.start(). The push guide covers the Firebase side of the setup.

Building for the other platforms too? AppAmbit has an SDK for iOS, React Native, Flutter, .NET MAUI, .NET and Avalonia. Each one takes its own App Key and reports into the same dashboard, on the same team and the same bill.

Try it on your own app

The free tier is enough to point the SDK at a real build and read your own sessions.

Ready when you are

Write the line. Watch the first session land.

Create a free account, paste your App Key into onCreate, and run the app. The first session shows up while your emulator is still open, and whatever the device recorded on a bad connection is waiting the moment it reconnects. Kotlin or Java, API 21 and up, no credit card.

Create your free account Read the docs

One line, and Android reports.

Start free