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

.NET · C#

One call at startup. Whatever .NET you are writing.

Add one NuGet reference and call AppAmbitSdk.Start once, and your app reports sessions, device details and crashes on its own. This is the package the MAUI and Avalonia ones are built on, so it works with or without a UI framework attached.

Start free See the setup
NuGet: com.AppAmbit.Sdk Open source .NET 10

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

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

NuGet reference, and no UI framework required.

Five

Target frameworks in the package, desktop and mobile.

Zero

Lines of platform code you have to write.

4.2

Current release, resolved from NuGet.

Session Timeline

You write the app. The timeline writes itself.

The session timeline records what a person did on the way to a crash: the screens 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 by hand.

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 package, every head

The same assembly under everything you ship.

com.AppAmbit.Sdk is the core. MAUI and Avalonia add a thin layer for how their frameworks start, and everything else on this page is identical wherever you reference it.

One package under the others. The MAUI and Avalonia packages are thin layers on this one, so what you learn here is what you use there.
One app per operating system. An app in AppAmbit belongs to one OS, so a codebase that ships to more than one gets a key for each, and a crash never lands in the wrong list.
The same calls everywhere. Analytics.TrackEvent, Crashes.LogError and the rest do not change when the head does.
Startup.cs · C# 
var key = OperatingSystem.IsAndroid()
    ? "<ANDROID-APPKEY>"
    : OperatingSystem.IsIOS()
        ? "<IOS-APPKEY>"
        : "<DESKTOP-APPKEY>";
 
AppAmbitSdk.Start(key);
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 as early as your app has a startup path. 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 version 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 your app moves, 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 whatever the project is, 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. Nothing else comes with it beyond a JSON serializer and a local SQLite store for the offline queue.

# the current release
dotnet add package com.AppAmbit.Sdk
<!-- or pin it yourself, then dotnet restore -->
<ItemGroup>
  <PackageReference Include="com.AppAmbit.Sdk"
                    Version="4.2.0" />
</ItemGroup>
One reference. NuGet resolves the platform assemblies. .NET 10
02

Start it once

As early as your app has a startup path: a WPF App constructor, a host builder, a native head. The SDK is up before the first screen and the first session covers the whole launch.

App.xaml.cs · C# 
using AppAmbit;
 
// once, as early as your app has a startup path
AppAmbitSdk.Start("<YOUR-APPKEY>");
The App Key is on the app's Info page in the dashboard. One call
03

Run it

Run the app the way you already run it. The first session opens as the process starts and lands while the app is still up.

Terminal · first run 
# the project you added it to
dotnet run
The session lands while the app is still running. 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
Startup.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 .NET does the package need?
It ships assemblies for net10.0 plus the android, ios, maccatalyst and windows target frameworks, so any project on .NET 10 can reference it, with or without a UI framework attached.
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.
Can I use it without MAUI or Avalonia?
Yes. This is the package the other two are built on. The repository ships a WPF sample alongside the MAUI ones, and the same calls work from a service or a console host.
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 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.

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.