---
title: "Crash Reporter Client"
description: "Learn about Sentry's Unreal Engine integration with Crash Reporter Client."
url: https://docs.sentry.io/platforms/unreal/configuration/setup-crashreporter/
---

# Crash Reporter Client | Sentry for Unreal Engine

Installation of a Sentry SDK is not required in order to capture the crashes of your Unreal Engine application or game, because Sentry supports the *UE Crash Reporter*.

Starting from SDK version 1.8.0, the Sentry plugin includes its own [Sentry Crash Reporter](https://docs.sentry.io/platforms/unreal/configuration/setup-crashreporter.md#sentry-crash-reporter) - an alternative to the built-in UE Crash Reporter that works through the Sentry SDK pipeline and supports user feedback.

To integrate your UE game or application with Sentry, the following steps are required:

1. Include the *UE Crash Reporter* in your game or application.
2. Include Debug information in the crash reports.
3. Add the Unreal Engine Endpoint to the relevant configuration file.
4. Upload your games' symbols so Sentry can display function names and line numbers.
5. Optionally, enable Event Attachments for your Sentry project.

Below we'll break down each step in detail.

## [UE Crash Reporter](https://docs.sentry.io/platforms/unreal/configuration/setup-crashreporter.md#ue-crash-reporter)

The UE Crash Reporter is provided out of the box by Epic Games. It is able to collect relevant information about the crash and send it to a service like Sentry to process.

Epic Games only provides the Crash Reporter Client on desktop (Windows, Mac, Linux). In order to capture crashes on mobile and consoles, you need to use the Sentry SDK, which support all platforms, including desktop.

Adding it to your game means that in case a crash happens, the following dialog is displayed to the user:

### [Using the UE Crash Reporter on Windows](https://docs.sentry.io/platforms/unreal/configuration/setup-crashreporter.md#using-the-ue-crash-reporter-on-windows)

The UE Crash Reporter works if the Sentry SDK is installed. Sentry SDK can help with configuring the UE Crash Reporter, uploading debug symbols, and enriching crash reports with custom data. **Starting from UE 5.2** users have to choose between the two available crash capturing mechanisms - the UE Crash Reporter or the `sentry-native` library that's integrated into the Sentry plugin. By default, the `sentry-native` library is used instead of the UE Crash Reporter (see "Enable automatic crash capturing (Windows, UE 5.2+)" in the plugin settings). The two solutions are mutually exclusive and can't be used simultaneously.

## [Sentry SDK and UE Crash Reporter feature comparison](https://docs.sentry.io/platforms/unreal/configuration/setup-crashreporter.md#sentry-sdk-and-ue-crash-reporter-feature-comparison)

Sentry SDK can integrate with the UE Crash Reporter, but it also offers additional features beyond those provided by the built-in tool. The table below outlines the key feature differences:

| Feature                   | Sentry SDK                | Crash Reporter       |
| ------------------------- | ------------------------- | -------------------- |
| Supported engine versions | All UE 5 and UE 4.27      | Built-in engine tool |
| Supported platforms       | Desktop, mobile, consoles | Desktop              |
| Crash capturing \*        | Supported \*\*            | Supported            |
| Additional event context  | Supported                 | Supported            |
| Automatic breadcrumbs     | Supported                 | Not supported        |
| Screenshot attachment     | Supported \*\*\*          | Not supported        |
| Crash events filtering    | Supported                 | Not supported        |
| Release health monitoring | Supported                 | Not supported        |
| Performance insights      | Supported                 | Not supported        |

Legend: `*`: On Windows, the underlying crash capturing mechanisms used in the Sentry SDK and the UE Crash Reporter are mutually exclusive. `**`: On Windows, crash capturing is supported out of the box starting from UE 5.2. `***`: Currently this [feature](https://github.com/getsentry/sentry-unreal/issues/567) is supported only on Windows/Linux.

### [Using Sentry SDK and UE Crash Reporter together](https://docs.sentry.io/platforms/unreal/configuration/setup-crashreporter.md#using-sentry-sdk-and-ue-crash-reporter-together)

Adding event context (e.g., tags, custom breadcrumbs, or user information) can always be done through the unified Sentry SDK interface. While only one crash-capturing mechanism can be active at a time, both solutions can be used together for context enrichment, helping to improve the debugging process.

Features like crash events filtering, screenshot attachment and release health monitoring require the Sentry SDK to be enabled for crash capturing to work properly.

## [Include the UE Crash Reporter](https://docs.sentry.io/platforms/unreal/configuration/setup-crashreporter.md#include-the-ue-crash-reporter)

You can add the *Crash Reporter Client* to your game in your *Project Settings*.

The simplest way is to search the option: `Crash Reporter`:

The option is located under *Project > Packaging* menu, then select *show advanced* followed by checking the box for: `Include Crash Reporter`.

## [Configure the Crash Reporter Endpoint](https://docs.sentry.io/platforms/unreal/configuration/setup-crashreporter.md#configure-the-crash-reporter-endpoint)

Now that the *Crash Reporter* is included, UE needs to know where to send the crash. For that, we need to add the Sentry *Unreal Engine Endpoint* from the *Client Keys* settings page to the game's configuration file. This will include whichever project within Sentry you want to see real-time crashes for. That's accomplished by configuring the `CrashReportClient` in the *DefaultEngine.ini* file. You'll need to change the engine to do this to work.

Edit the file:

> engine-dir\Engine\Programs\CrashReportClient\Config\DefaultEngine.ini

Add the configuration section:

`DefaultEngine.ini`

```ini
[CrashReportClient]
CrashReportClientVersion=1.0
DataRouterUrl="___UNREAL_URL___"
```

If a `[CrashReportClient]` section already exists, simply changing the value of `DataRouterUrl` is enough.

Alternatively, the endpoint can be added automatically to the *DefaultEngine.ini* file by using the Sentry configuration window.

Navigate to the editor's menu **Project Settings > Plugins > Sentry**, set the Sentry *Unreal Engine Endpoint* in the corresponding input field, and click the **Update global settings** button to apply changes. The default endpoint value can be restored by clicking the **Reset** button once the *Crash Reporter* is no longer needed.

## [Configure the Crash Reporter Attributes](https://docs.sentry.io/platforms/unreal/configuration/setup-crashreporter.md#configure-the-crash-reporter-attributes)

Basic attributes can be reconfigured by providing special game data to the crash reporter. Do this by setting the `__sentry` game data key to a JSON value containing Sentry specific attributes:

```cpp
#include "GenericPlatform/GenericPlatformCrashContext.h"
#include "Dom/Json.h"

void ConfigureCrashReporter()
{
    TSharedPtr<FJsonObject> config = MakeShareable(new FJsonObject);

    // sentry specific attributes go here
    config->SetStringField("release", "my-project-name@2.3.12");
    config->SetStringField("environment", "production");

    TSharedPtr<FJsonObject> tags = MakeShareable(new FJsonObject);
    tags->SetStringField("tag1", "value1");
    tags->SetStringField("tag2", "value2");
    config->SetObjectField("tags", tags);

    TSharedPtr<FJsonObject> user = MakeShareable(new FJsonObject);
    user->SetStringField("ip_address", "{{auto}}");
    user->SetStringField("email", "jane.doe@example.com");
    config->SetObjectField("user", user);

    TSharedPtr<FJsonObject> character = MakeShareable(new FJsonObject);
    character->SetStringField("name", "Mighty Fighter");
    character->SetNumberField("age", 19.0);
    TSharedPtr<FJsonObject> contexts = MakeShareable(new FJsonObject);
    contexts->SetObjectField("character", character);
    config->SetObjectField("contexts", contexts);

    FString jsonConfig;
    TSharedRef<TJsonWriter<>> jsonWriter = TJsonWriterFactory<>::Create(&jsonConfig);
    FJsonSerializer::Serialize(config.ToSharedRef(), jsonWriter);

    FGenericCrashContext::SetGameData(TEXT("__sentry"), jsonConfig);
}
```

You need to call the `ConfigureCrashReporter` some time after your game starts. Any [event attribute](https://develop.sentry.dev/sdk/foundations/transport/event-payloads/) can be set.

You should configure Crash Reporter attributes before initializing the Sentry SDK. Otherwise, some information may get overwritten and lost.

The Sentry SDK provides an API which allows you to set Crash Reporter attributes as well.

Depending on the version of Unreal Engine you are using, you may have to add JSON support to the build script (`MyProject.build.cs`):

```csharp
PublicDependencyModuleNames.AddRange(new string[] { ..., "Json" });
```

## [Sentry Crash Reporter](https://docs.sentry.io/platforms/unreal/configuration/setup-crashreporter.md#sentry-crash-reporter)

Available starting from Sentry Unreal SDK version 1.8.0. Supported on Windows and Linux only.

Starting from version 1.8.0, the Sentry Unreal plugin ships with an optional **Sentry Crash Reporter** - a standalone application that can be used instead of the default UE Crash Reporter. When enabled, it displays a dialog to users after a crash, allowing them to review crash details and provide feedback before the report is submitted to Sentry.

Unlike the built-in UE Crash Reporter, the Sentry Crash Reporter works through the Sentry SDK pipeline and doesn't require modifying engine configuration files. This also means it requires Sentry's own crash capturing to be enabled (see "Enable automatic crash capturing (Windows, UE 5.2+)" in the plugin settings).

### [Enabling the Sentry Crash Reporter](https://docs.sentry.io/platforms/unreal/configuration/setup-crashreporter.md#enabling-the-sentry-crash-reporter)

To enable it, navigate to **Project Settings > Plugins > Sentry > General > Native** and toggle **Enable external crash reporter**.

Alternatively, add the following to your project's configuration `.ini` file:

```ini
[/Script/Sentry.SentrySettings]
EnableExternalCrashReporter=True
```

### [Customizing the Crash Reporter](https://docs.sentry.io/platforms/unreal/configuration/setup-crashreporter.md#customizing-the-crash-reporter)

You can customize the appearance of the Sentry Crash Reporter directly from the plugin settings. Navigate to **Project Settings > Plugins > Sentry > General > Native** and expand the **External crash reporter appearance** section. Each property has an override toggle - only properties you explicitly enable will be applied:

* **Window title** - Custom title for the crash reporter window.
* **Header text** - Header text shown in the crash reporter dialog.
* **Header description** - Description text shown below the header. Leave empty to hide.
* **Submit button label** - Label for the submit/send button.
* **Cancel button label** - Label for the cancel button. Set to empty string to hide the button.
* **Accent color** - Primary accent color used for the crash reporter UI elements.
* **Window closable** - When disabled, the user cannot close the crash reporter window without submitting the report. The native close button is disabled and the cancel button is hidden. Enabled by default.

These settings are applied each time the SDK initializes. Properties that are not overridden will use the crash reporter's built-in defaults.

#### [Using a Custom Crash Reporter Build](https://docs.sentry.io/platforms/unreal/configuration/setup-crashreporter.md#using-a-custom-crash-reporter-build)

For more advanced customization (such as custom logos or layout changes), you can fork the [sentry-desktop-crash-reporter](https://github.com/getsentry/sentry-desktop-crash-reporter) project and build a custom version.

To build on Windows:

```powershell
cd sentry-desktop-crash-reporter
dotnet publish -f net9.0-desktop -r win-x64 Sentry.CrashReporter/Sentry.CrashReporter.csproj -o build-output
```

For other platforms, replace the runtime identifier with `win-arm64`, `linux-x64`, or `linux-arm64`.

Copy the output executable into the plugin's ThirdParty binaries directory:

* **Windows**: `Plugins/sentry-unreal/Source/ThirdParty/Win64/bin/Sentry.CrashReporter.exe`
* **Linux**: `Plugins/sentry-unreal/Source/ThirdParty/Linux/bin/Sentry.CrashReporter`

After replacing the executable, delete the project's `Build` and `Intermediate` directories and rebuild to ensure the updated binary is picked up.

Refer to the project's [customization guide](https://github.com/getsentry/sentry-desktop-crash-reporter/blob/main/CUSTOMIZATION.md) for details on what can be changed.

### [Stacktrace Display](https://docs.sentry.io/platforms/unreal/configuration/setup-crashreporter.md#stacktrace-display)

The Sentry Crash Reporter can display a symbolicated stacktrace of the crashed thread, allowing users to review the call stack directly in the crash dialog before submitting the report.

This feature requires client-side stack walking, which is supported through two backend configurations:

* **[Native backend](https://docs.sentry.io/platforms/unreal/configuration/native-backend.md)**: Performs stack walking and symbolication automatically using the platform's debug APIs. No additional configuration is needed.
* **Crashpad backend**: Requires a custom build of `sentry-native` with the `CRASHPAD_ENABLE_STACKTRACE` CMake flag enabled. See [below](https://docs.sentry.io/platforms/unreal/configuration/setup-crashreporter.md#building-sentry-native-with-stacktrace-support) for instructions.

For **Shipping builds**, the stacktrace can only be symbolicated if debug information is available at runtime. Enable **Include Debug Files in Shipping Builds** in **Project Settings > Packaging** to ensure function names are resolved in the crash reporter dialog.

#### [Building sentry-native With Stacktrace Support](https://docs.sentry.io/platforms/unreal/configuration/setup-crashreporter.md#building-sentry-native-with-stacktrace-support)

To enable client-side stacktrace display when using the Crashpad backend, you need to rebuild `sentry-native` with the `CRASHPAD_ENABLE_STACKTRACE` CMake flag. The example below shows a Windows build — for other platforms, refer to the [sentry-native build documentation](https://github.com/getsentry/sentry-native#build-and-installation) and the [CI build scripts](https://github.com/getsentry/sentry-unreal/tree/main/scripts) in the sentry-unreal repository.

Clone [sentry-native](https://github.com/getsentry/sentry-native) and check out the version that matches your plugin (pinned under `modules/sentry-native` in the [sentry-unreal](https://github.com/getsentry/sentry-unreal) repository). Then build:

```powershell
cd D:\projects\sentry-native

cmake -G "Visual Studio 17 2022" -S . -B build `
    -D SENTRY_BACKEND=crashpad `
    -D SENTRY_SDK_NAME=sentry.native.unreal `
    -D SENTRY_BUILD_SHARED_LIBS=OFF `
    -D CRASHPAD_ENABLE_STACKTRACE=ON

cmake --build build --target sentry --config RelWithDebInfo --parallel
cmake --build build --target crashpad_handler --config RelWithDebInfo --parallel
cmake --install build --prefix install --config RelWithDebInfo
```

Copy the build output into your project's plugin directory:

* `install/lib/*` → `Plugins/sentry-unreal/Source/ThirdParty/Win64/Crashpad/lib/`
* `install/bin/crashpad_handler.exe` → `Plugins/sentry-unreal/Source/ThirdParty/Win64/Crashpad/bin/`
* `install/include/sentry.h` → `Plugins/sentry-unreal/Source/ThirdParty/Win64/Crashpad/include/`

After replacing binaries, delete your project's `Build` and `Intermediate` directories and rebuild.

The `CRASHPAD_ENABLE_STACKTRACE` feature is experimental. On Linux, it requires the `libunwind-ptrace` development package.

## [Upload Debug Symbols](https://docs.sentry.io/platforms/unreal/configuration/setup-crashreporter.md#upload-debug-symbols)

To allow Sentry to fully process native crashes and provide you with symbolicated stack traces, you need to upload *Debug Information Files* (sometimes also referred to as *Debug Symbols* or just *Symbols*). We recommend uploading debug information during your build or release process.

The Sentry SDK can handle uploading [debug symbols](https://docs.sentry.io/platforms/unreal/configuration/debug-symbols.md) automatically at build time.

For all libraries where you'd like to receive symbolication, **you need to provide debug information**. This includes dependencies and operating system libraries.

In addition to Debug Information Files, Sentry needs *Call Frame Information* (CFI) to extract accurate stack traces from minidumps of optimized release builds. CFI is usually part of the executables and not copied to debug symbols. Unless you are uploading Breakpad symbols, be sure to also include the binaries when uploading files to Sentry.

For more information on uploading debug information and their supported formats, see [Debug Information Files](https://docs.sentry.io/platforms/unreal/data-management/debug-files.md).

## [Size Limits](https://docs.sentry.io/platforms/unreal/configuration/setup-crashreporter.md#size-limits)

Event ingestion imposes size limits on UE crash reports. These limits are subject to future change and defined currently as:

* *40MB* for a compressed request
* *200MB* for the full crash report after decompression

## [Issues With the Crash Reporter](https://docs.sentry.io/platforms/unreal/configuration/setup-crashreporter.md#issues-with-the-crash-reporter)

Check out this community-generated [thread in Sentry's forum](https://forum.sentry.io/t/unreal-engine-crash-reporter-cant-get-it-to-work/7643) for UE Crash Reporter troubleshooting tips and solutions.

## [Store Minidumps as Attachments](https://docs.sentry.io/platforms/unreal/configuration/setup-crashreporter.md#store-minidumps-as-attachments)

[Minidumps](https://docs.sentry.io/platforms/native/guides/minidumps.md#what-is-a-minidump) may contain sensitive information about the target system, such as environment variables, local pathnames, or in-memory representations of input fields, including passwords. By default, Sentry only uses minidump files to create events and immediately drops them. All sensitive information is stripped from the resulting events.

All attachments types, including log files, screenshots and minidumps (if you enable Store Minidumps As Attachments), are stored for 30 days when sent to Sentry. Note that Sentry does not apply data scrubbing to attachments.

☝ This feature is supported on Windows, Linux, and Android.

### [Enabling Minidump Storage](https://docs.sentry.io/platforms/unreal/configuration/setup-crashreporter.md#enabling-minidump-storage)

You can enable *Store Minidumps As Attachments* in your organization or project settings under **Security & Privacy**. By default, this setting is disabled. Determine the maximum number of crash reports that will be stored per issue; disabled, unlimited, or maximum per issue:

If you set a limit per issue, as in the example above, a limit of 5, Sentry will store the first 5 attachments associated with this issue, but drop any that follow. To make room for additional attachments, delete them. Sentry will then accept attachments until the limit is reached again.