Error alerts for .NET

Your .NET errors, straight to Telegram, Discord or Pushover

Add one NuGet package, and every new error of your application lands in the chat you already read: the first occurrence at once, in full, and repeats as short summaries.

Start free Read the docs

dotnet add package BugsRadar

Free plan · no event quotas · your events are never stored

Shop · errors

your bot, your chat

Today

🔴 Shop API · Error

System.TimeoutException: The operation has timed out.

Shop.Payments.PaymentService.ChargeAsync

Production · web-1 · v1.4.2 · 2026-09-22 12:00:05 UTC

OrderId = 1042

at Shop.Payments.PaymentService.ChargeAsync(Order order)
at Shop.Orders.OrderService.CreateOrder(Int32 orderId)

12:00

🔴 Shop API · ×157 more

System.TimeoutException: The operation has timed out.

Shop.Payments.PaymentService.ChargeAsync

×157 more since the last message · 158 total since 2026-09-22 12:00:05 UTC · last 2026-09-22 12:09:58 UTC

12:10

The first occurrence and a summary of its repeats, as they arrive in Telegram.

One package

Report through what your app already uses

The BugsRadar package is an ILogger provider, a Serilog sink and a direct call in one. Use any of them, or all three — an error reported twice still arrives once.

Reports leave through a background queue: your code never waits for the network.
Repeats of the same error travel as one request with a count, so a crash loop costs a request every few seconds, not thousands per second.
When the server asks to slow down, the client waits; network failures are retried.
On shutdown the queue is drained before the application exits.
Targets .NET Standard 2.0: ASP.NET Core, worker services, desktop and console apps.

Read the setup guide →

ILogger provider

Program.cs

using BugsRadar.Extensions.DependencyInjection;
using BugsRadar.Extensions.Logging;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddBugsRadar(configuration =>
{
    configuration.ApiKey = "<your project API key>";
    configuration.Environment = builder.Environment.EnvironmentName;
});
builder.Logging.AddBugsRadar();

// Anywhere in your code: Error and above goes to BugsRadar
logger.LogError(exception, "Order {OrderId} failed", orderId);

Serilog sink

Program.cs

using BugsRadar.Extensions.Serilog;
using Serilog;

Log.Logger = new LoggerConfiguration()
    .WriteTo.BugsRadar("<your project API key>")
    .CreateLogger();

// Error and above goes to BugsRadar
Log.Error(exception, "Payment {PaymentId} declined", paymentId);

Direct call

OrderService.cs

using BugsRadar;

public class OrderService
{
    private readonly IBugsRadar _bugsRadar;

    public OrderService(IBugsRadar bugsRadar)
    {
        _bugsRadar = bugsRadar;
    }

    public void CreateOrder(int orderId)
    {
        try
        {
            // ...
        }
        catch (Exception error)
        {
            _bugsRadar.SendException(error, "Order creation failed", module: "Orders");
        }
    }
}

Console app

Program.cs

using BugsRadar;

using var bugsRadar = new BugsRadarClient(new BugsRadarConfiguration
{
    ApiKey = "<your project API key>"
});

try
{
    RunImport();
}
catch (Exception error)
{
    bugsRadar.SendException(error);
}

await bugsRadar.FlushAsync(); // before exit; Dispose also drains the queue

Built for the bad day

See every new error. Never drown in repeats.

When something breaks at scale, you learn about it at once, and your chat stays readable.

First alert at once, then summaries

The first occurrence arrives immediately, with all its details. Repeats of the same error are counted and come as one summary: “×157 more since the last message”.

Bundles, not floods

When errors come faster than your channel accepts, they arrive bundled: one message, one line per error, grouped by project.

Duplicates dropped

An exception logged through ILogger and reported by hand arrives once. There is nothing to configure.

Your app never waits

Reports leave through a background queue in your process, so a slow network or a slow channel never holds up your requests.

Forward-only

An event stays in memory only until it is delivered. Nothing is written to a database, so there is no archive of your errors on our side.

Credentials encrypted

Bot tokens and webhook URLs are encrypted with AES-256-GCM. After saving you only see a mask, and they never appear in logs.

FAQ

Questions developers ask

Does BugsRadar store my errors?

No. An event stays in memory only until it is delivered to your channels; nothing is written to a database. BugsRadar keeps only what it needs to run: your email, your projects and the encrypted settings of your channels.

What happens when my app throws thousands of errors a minute?

The package folds repeats into one request with a count, and BugsRadar groups them on its side: you get the first occurrence at once and summaries after that. If errors come faster than your channel accepts, they are bundled into one message with a line per error.

Why do I need my own Telegram bot?

Messages go from your bot to your chat, so you stay in control: you choose who is in the chat and can revoke the token at any time. BugsRadar stores the token encrypted and shows only a mask after saving.

Which .NET versions are supported?

The package targets .NET Standard 2.0, so it runs on modern .NET and on .NET Framework: ASP.NET Core, worker services, desktop and console apps.

I use BugsRadar 1.x. What changes?

API v2 is shut down, and versions below 3.0.0.1 no longer deliver error reports. Update the package to 3.0.0.1 or later: its major version matches the API version it talks to. See Upgrading from 1.x.

Get your first alert in a few minutes

Start free Read the docs