●  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.

Avalonia · C#

One call when the framework is up. Desktop and mobile report back.

Add one NuGet reference and call AppAmbitSdk.Start in OnFrameworkInitializationCompleted, and your Avalonia app reports sessions, device details and crashes on its own, from a desktop and from a phone.

Start free See the setup
NuGet: com.AppAmbit.Avalonia Open source Avalonia 11.3.9+

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

App.axaml.cs · C# Live 
using AppAmbitAvalonia;
 
public partial class App : Application
{
    public override void OnFrameworkInitializationCompleted()
    {
        // the whole integration
        AppAmbitSdk.Start("<YOUR-APPKEY>");
 
        base.OnFrameworkInitializationCompleted();
    }
}
Sessions, device details and crashes start from that call. com.AppAmbit.Avalonia 4.2.0
One

NuGet reference, on top of the core SDK.

Four

Platforms. Windows, macOS, iOS and Android.

Zero

Lines of platform code you have to write.

11.3

Minimum Avalonia. The package asks for 11.3.9.

Session Timeline

You write the views. The timeline writes itself.

The session timeline records what a person did on the way to a crash: the views they moved through and the events you sent, in order, with the crash at the end. It comes with the package, so there is nothing to instrument inside your windows.

01

It is on from the first line

The session timeline starts with the SDK. There is no separate call to make and nothing to register inside your views.

02

Your own steps join it

Anything you send with Analytics.TrackEvent lands on the same timeline, so a business step reads next to the navigation that led to it.

03

It travels with the crash

When a crash arrives, the timeline arrives with it. You open the report and the last six things that happened are already there.

How the session timeline works
Session timeline · one session Recording
ScreenHomePage0.0s
EventProduct openedsku=NET-204
ScreenProductPage2.4s
ScreenCartPage9.1s
EventCheckout started11.7s
CrashNullReferenceException: Object reference not set12.0s

Six breadcrumbs, and the last one is the crash. This is what arrives attached to the report.

See a session timeline

Every crash lands inside the session that led to it, with the run-up already attached.

One codebase, four platforms

A laptop and a phone report into the same dashboard.

Avalonia gives you one set of views for desktop and mobile. AppAmbit keeps one app per operating system, so give each head its own App Key and read them side by side in the same team.

Desktop and mobile from one codebase. The package builds for plain net10.0 as well as the Android and iOS heads, so the same views report from a laptop and from a phone.
One app per operating system. An app in AppAmbit belongs to one OS, so give each head its own App Key and a crash never lands in the wrong list.
The same calls either way. Analytics.TrackEvent, Crashes.LogError and the rest do not change when the head does.
App.axaml.cs · C# 
var mobile = OperatingSystem.IsAndroid()
          || OperatingSystem.IsIOS();
 
AppAmbitSdk.Start(mobile ? MobileKey : DesktopKey);
One call site, whichever head is running. OperatingSystem
Create your apps

One team, one App Key per operating system, and every head on the same free tier.

The whole API

Six calls, and you have seen all of it.

There is no client to configure, no pipeline to describe and no schema to declare. Every one of these is a static call on a class you already have in scope, awaited like anything else in C#.

AppAmbitSdk.Start(appKey)

Turn it on

One call in OnFrameworkInitializationCompleted. Sessions, device details and crashes start from that line.

Session Timeline

Analytics.TrackEvent(title, data)

Record something

A name and a dictionary of strings. The dashboard groups by the name and keeps the properties on each occurrence.

Event Tracking

Crashes.LogError(exception, properties)

Report a caught error

The exception you already handled, sent as a log rather than a crash. The file and the line come from the compiler, so you do not pass them.

Crash and Error Monitoring

Crashes.LogError(message)

Report without an exception

The same list, for the times you have a sentence and no exception object. Properties work here too.

Analytics.EnableManualSession()

Draw the sessions yourself

Sessions start and end on their own. Turn that off and call StartSession and EndSession where they belong in your own flow.

Crashes.GenerateTestCrash()

Prove the pipeline

Force one on purpose and watch it arrive. The fastest way to know the App Key and the build are wired up.

Nothing waits on the network. Every call writes to a local SQLite queue first and the queue is sent in batches when a connection is there, so a flight or a tunnel does not cost you a session.

The context comes with it. A crash arrives inside the session it happened in, next to the breadcrumbs and the events that came before it, so you read the run-up rather than a bare stack.

Get an App Key

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

Everything else in the account

The rest of AppAmbit is already pointed at this app.

All of it runs on the App Key you pasted in and the team the app belongs to. Nothing on this row is another vendor to pick, another SDK to add or another invoice to get approved.

App Analytics

Who opened the app, on which OS and build, and how long they stayed.

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 that led to the crash, recorded as you move between views, so you read a path instead of guessing one.

Breadcrumbs

Remote config

Flip a flag or change a value and your app picks it up, with no rebuild and no wait behind a store.

Remote config

App Database

Real SQL from C#, with no server to run and no connection string compiled into the app.

App Database

Cloud Code

Call a Node.js function you deployed inside AppAmbit, and get the response back typed or dynamic.

Cloud Code

Content management

Read published content types and entries into your own model class, so copy can change without a release.

CMS guide

Push notifications

One more package beside the core one, your own credentials, and the tokens already tied to your App Key.

Push notifications

Build delivery

Hand a build 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.

Build delivery

The build your tester installs is the build you read crashes from.

Upload the artifact from the pipeline you already run, hand testers a link, and the crashes that come back are already tied to the build they came from. The build guides have the pipeline steps.

.ipa .apk Build delivery

GitHub Actions

Build your artifact 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 none of them are platform code.

Create your app in the dashboard to get an App Key, then add one reference and one call. These three steps are the same for every head your project builds for, because the SDK call does not change with the target.

01

Add the package

One reference, from NuGet. Version 4.2.0 is the current release. It pulls in com.AppAmbit.Sdk and asks for Avalonia 11.3.9 or newer.

# the current release
dotnet add package com.AppAmbit.Avalonia
<!-- or pin it yourself, then dotnet restore -->
<ItemGroup>
  <PackageReference Include="com.AppAmbit.Avalonia"
                    Version="4.2.0" />
</ItemGroup>
One reference. NuGet resolves the rest. Avalonia 11.3.9+
02

Start it when the framework is ready

In OnFrameworkInitializationCompleted, before the base call, so the SDK is up before the first window and the first session covers the whole launch.

App.axaml.cs · C# 
using AppAmbitAvalonia;
 
    public override void OnFrameworkInitializationCompleted()
    {
        AppAmbitSdk.Start("<YOUR-APPKEY>");
        base.OnFrameworkInitializationCompleted();
    }
The App Key is on the app's Info page in the dashboard. One call
03

Run it

Run the project the way you already do. The first run has to be a full build, since a hot reload will not pick up a new native dependency.

Terminal · first run 
# the project you added it to
dotnet run --project MyApp.Desktop
The session lands while the window is still open. First run

Prefer the long version? The getting started guide covers the same three steps with the dashboard screens next to them.

Create your App Key

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

Push notifications

One more package, not another vendor.

Push runs on the same App Key and the same install. You bring the APNs and Firebase credentials from your own developer accounts, AppAmbit keeps the device tokens, and you send from the dashboard or from a Cloud Code function.

Add com.AppAmbit.PushNotifications next to the core package and start it after the SDK. It covers the Android and iOS heads, so a desktop build keeps compiling and simply has no push.
Two listeners, and a handler for the killed app. SetForegroundListener and SetOpenedListener take a plain Action, and registering again replaces the previous one rather than stacking a second.
The payload is a record. PushNotificationData carries title, body, imageUrl and your own data, plus the AndroidPushData and IosPushData blocks for the fields only one platform has.
How push notifications work
App.axaml.cs · push 
PushNotifications.Start();
 
// ask when the moment makes sense, not at launch
PushNotifications.RequestNotificationPermission();
 
// fires when the user taps one, in any app state
PushNotifications.SetOpenedListener(push =>
{
    if (push.Data?.TryGetValue("screen", out var s) == true)
        GoTo(s);
});
Both calls go after the SDK starts, which registers the device. Android and iOS
Set up push

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

Questions

Answered straight.

Which Avalonia version does it need?
The package asks for Avalonia 11.3.9 or newer, and it references com.AppAmbit.Sdk underneath, so a restore brings both down together.
Do I have to write any platform code?
No. The package carries the platform sides with it. You add one reference, start the SDK once, and build as usual.
What does it cost me at runtime?
A background queue and a small SQLite file. Everything is batched, retried and sent when the network is there, so a plane ride does not lose a session.
Can I use it with my own logging?
Yes. Crashes.LogError is additive, so keep whatever logger you already have and send AppAmbit the errors you want to read next to your crashes.
Does the same package cover the desktop and the phone?
Yes. One reference builds for Windows and macOS as well as for the Android and iOS heads, and the call you write is the same in all of them. Push notifications are the one part that covers only the mobile heads.
Where do the file and the line in a log come from?
The compiler. Crashes.LogError takes CallerFilePath and CallerLineNumber, so the location is filled in at the call site and you never pass it yourself.

Building for the other platforms too? AppAmbit has an SDK for iOS, Android, React Native, Flutter, .NET MAUI and .NET. 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.

Add the package. Watch the first session land.

One reference, one call, and the first session shows up while the app is still open. The database, the functions and the flags are already behind the same key.

Start free Read the docs

No credit card required. Free tier available.