Error Tracking | Datadog

Don’t go chasing errors.
Build the next big thing.

Group, prioritize and resolve errors with speed and confidence. All in one place.

Error Tracking Demo

Error Tracking supports 10+ languages and frameworks

typescript.svg
android.svg
go.svg
flutter.svg
ios.svg
cplusplus.svg
react.svg
javascript.svg
java.svg
net.svg
node.svg

Debug less, build more

Focus on what matters

Errors are automatically grouped into issues using stack traces, messages, and runtime metadata. Cut through the noise, simplify triage, and get to the root of issues faster.

cut the noise

Ship with confidence

Get real-time alerts for new, recurring, and high-volume errors. Prioritize issues by impact so you can act early, prevent regressions, and protect the user experience without slowing down development.

catch it early

Fix with context

Debug without the guesswork. Use code-level context, telemetry like logs and environment data, and suspect commits to understand what caused the issue. With AI-powered insights and issue classification, you can resolve errors quickly and stay focused on building.

smart fixes

Grow your product, not your tools

Start with Error Tracking and expand into full observability all on a single platform. As your app grows, Datadog grows with you, providing deep visibility into performance, user behavior, and everything you need to move fast with confidence.

one platform

Get started in minutes

Select what type of errors to track

Copied!
1
npm i @datadog/browser-rum
Copied!
1
2
3
4
5
6
7
8
9
10
11
12
import { datadogRum } from '@datadog/browser-rum';

datadogRum.init({
  applicationId: '<APP_ID>',
  clientToken: '<CLIENT_TOKEN>',
  service: '<SERVICE>',
  env: '<ENV_NAME>',
  site: '<SITE>',
  // version: '1.0.0',
  trackUserInteractions: true,
  trackResources: true,
});
Copied!
1
npm install @datadog/browser-rum @datadog/browser-rum-react
Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
import { datadogRum } from '@datadog/browser-rum';
import { reactPlugin } from '@datadog/browser-rum-react';

datadogRum.init({
  applicationId: '<APP_ID>',
  clientToken: '<CLIENT_TOKEN>',
  service: '<SERVICE>',
  env: '<ENV_NAME>',
  site: '<SITE>',
  // version: '1.0.0',
  trackUserInteractions: true,
  trackResources: true,
  plugins: [reactPlugin({ router: true })],
});
Copied!
1
2
3
4
5
6
plugins {
    id("com.datadoghq.dd-sdk-android-gradle-plugin") version "<latest_version>"
}
dependencies {
    implementation "com.datadoghq:dd-sdk-android-rum:<latest_version>"
}
Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class SampleApplication : Application() {
    override fun onCreate() {
        super.onCreate()

        val clientToken = "<CLIENT_TOKEN>"
        val environmentName = "<ENV_NAME>"
        val appVariantName = "<APP_VARIANT_NAME>"

        val configuration = Configuration.Builder(
            clientToken = clientToken,
            env = environmentName,
            variant = appVariantName
        )
            .useSite(DatadogSite.US1)
            .build()
        Datadog.initialize(this, configuration, trackingConsent)

        val applicationId = "<APP_ID>"
        val rumConfiguration = RumConfiguration.Builder(applicationId)
            .trackUserInteractions()
            .useViewTrackingStrategy(strategy)
            .build()
        Rum.enable(rumConfiguration)
      NdkCrashReports.enable()
    }
}
Copied!
1
.package(url: "https://github.com/Datadog/dd-sdk-ios.git", .upToNextMajor(from: "2.0.0"))
Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import DatadogCore
import DatadogRUM
import DatadogCrashReporting

let appID = "<APP_ID>",
let clientToken = "<CLIENT_TOKEN>",
let environment = "<ENV_NAME>"
let service: "<service name>"

Datadog.initialize(
    with: Datadog.Configuration(
        clientToken: clientToken,
        env: environment,
   service: service
    ),
    trackingConsent: .granted
)

RUM.enable(
    with: RUM.Configuration(
        applicationID: appID,
        uiKitViewsPredicate: DefaultUIKitRUMViewsPredicate(),
        uiKitActionsPredicate: DefaultUIKitRUMActionsPredicate(),
 urlSessionTracking: RUM.Configuration.URLSessionTracking(),
 appHangThreshold: 0.25,
 trackWatchdogTerminations: true
    )
)


CrashReporting.enable()
Copied!
1
2
npm install @datadog/mobile-react-native
(cd ios && pod install)
Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import {
    BatchSize,
    DatadogProvider,
    DatadogProviderConfiguration,
    SdkVerbosity,
    UploadFrequency,
} from "@datadog/mobile-react-native";


const config = new DatadogProviderConfiguration(
    "<CLIENT_TOKEN>",
    "<ENV_NAME>",
    "30bb1c1b-b33b-4ed3-a5cc-70bd6f859228",
    true, // track user interactions (such as a tap on buttons).
    true, // track XHR Resources
    true // track Errors
)

config.nativeCrashReportEnabled = true
config.resourceTracingSamplingRate = 0;


// Wrap the content of your App component by a DatadogProvider component, passing it your configuration:
export default function App() {
    return (
        <DatadogProvider configuration={config}>
            <Navigation />
        </DatadogProvider>
    );
}
Copied!
1
2
dependencies:
  datadog_flutter_plugin: x.x.x
Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
final configuration = DatadogConfiguration(
  clientToken: 'pub8374a84c982012aeb74ba08a5ec91bb0',
  env: '<ENV_NAME>',
  site: DatadogSite.us1,
  nativeCrashReportEnabled: true,
  loggingConfiguration: DatadogLoggingConfiguration(),
  rumConfiguration: DatadogRumConfiguration(
    applicationId: '4115a060-e4eb-4f2e-8618-730d2d701770',
  ),
  firstPartyHosts: ['example.com'],

)..enableHttpTracking();

await DatadogSdk.runApp(configuration, TrackingConsent.granted, () async {
  runApp(MyApp());
});


RumUserActionDetector(
  rum: DatadogSdk.instance.rum,
  child: Scaffold(
    appBar: AppBar(
      title: const Text('RUM'),
    ),
    body: // Rest of your application
  ),
);
Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
sub RunUserInterface(args as dynamic)
    screen = CreateObject("roSGScreen")
    scene = screen.CreateScene("MyScene")
    screen.show()

    datadogroku_initialize({
        clientToken: "pub51f1a2be549cd82c034784c7d7d46548",
        applicationId: "f7f66b08-cbf3-4c94-b3ab-2ece1b759b9f"
        site: "us1",
        env: "<ENV_NAME>",
        sessionSampleRate: 100, ' the percentage (integer) of sessions to track
        launchArgs: args
    })
end sub
Copied!
1
npm i @datadog/browser-rum
Copied!
1
2
3
4
5
6
7
8
9
10
11
12
import { datadogRum } from '@datadog/browser-rum';

datadogRum.init({
   applicationId: '<APP_ID>',
   clientToken: '<CLIENT_TOKEN>',
   service: '<SERVICE>',
   env: '<ENV_NAME>',
   site: '<SITE>',
   // version: '1.0.0',
   trackUserInteractions: true,
   trackResources: true,
});
Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
// in common source set
fun initializeDatadog(context: Any? = null) {

    // context should be application context on Android and can be null on iOS
    val appClientToken = "<CLIENT_TOKEN>"
    val appEnvironment = "<ENV_NAME>"
    

    val configuration = Configuration.Builder(
            clientToken = appClientToken,
            env = appEnvironment,
            
    )
        .trackCrashes(true)
        .build()

    Datadog.initialize(context, configuration, trackingConsent)

    val applicationId = "<APP_ID>"
    val rumConfiguration = RumConfiguration.Builder(applicationId)
            // platform specific setup
            .apply {
                datadogPlatformSetup(this)
            }
            .build()

    Rum.enable(rumConfiguration)
}

internal expect fun datadogPlatformSetup(rumConfigurationBuilder: RumConfiguration.Builder)

// in iOS source set
internal actual fun datadogPlatformSetup(rumConfigurationBuilder: RumConfiguration.Builder) {
    with(rumConfigurationBuilder) {
        trackUiKitViews()
        trackUiKitActions()
        // check more iOS-specific methods
    }
}

// in Android source set
internal actual fun datadogPlatformSetup(rumConfigurationBuilder: RumConfiguration.Builder) {
    with(rumConfigurationBuilder) {
        useViewTrackingStrategy(//choose view tracking strategy//)
        trackUserInteractions()
        // check more Android-specific methods
    }
}
Copied!
1
2
3
DD_API_KEY=<API_KEY> DD_SITE="datadoghq.com" DD_APM_INSTRUMENTATION_ENABLED=host
DD_APM_ERROR_TRACKING_STANDALONE=true
DD_APM_INSTRUMENTATION_LIBRARIES=java:1 bash -c "$(curl -L https://install.datadoghq.com/scripts/install_script_agent7.sh)"
Copied!
1
2
3
DD_API_KEY=<API_KEY> DD_SITE="datadoghq.com" DD_APM_INSTRUMENTATION_ENABLED=host
DD_APM_ERROR_TRACKING_STANDALONE=true
DD_APM_INSTRUMENTATION_LIBRARIES=python:3 bash -c "$(curl -L https://install.datadoghq.com/scripts/install_script_agent7.sh)"
Copied!
1
2
3
DD_API_KEY=<API_KEY> DD_SITE="datadoghq.com" DD_APM_INSTRUMENTATION_ENABLED=host
DD_APM_ERROR_TRACKING_STANDALONE=true
DD_APM_INSTRUMENTATION_LIBRARIES=ruby:2 bash -c "$(curl -L https://install.datadoghq.com/scripts/install_script_agent7.sh)"
Copied!
1
2
3
DD_API_KEY=<API_KEY> DD_SITE="datadoghq.com" DD_APM_INSTRUMENTATION_ENABLED=host
DD_APM_ERROR_TRACKING_STANDALONE=true
DD_APM_INSTRUMENTATION_LIBRARIES=js:5 bash -c "$(curl -L https://install.datadoghq.com/scripts/install_script_agent7.sh)"
Copied!
1
2
3
DD_API_KEY=<API_KEY> DD_SITE="datadoghq.com" DD_APM_INSTRUMENTATION_ENABLED=host
DD_APM_ERROR_TRACKING_STANDALONE=true
DD_APM_INSTRUMENTATION_LIBRARIES=php:1 bash -c "$(curl -L https://install.datadoghq.com/scripts/install_script_agent7.sh)"
Copied!
1
2
3
DD_API_KEY=<API_KEY> DD_SITE="datadoghq.com" DD_APM_INSTRUMENTATION_ENABLED=host
DD_APM_ERROR_TRACKING_STANDALONE=true
DD_APM_INSTRUMENTATION_LIBRARIES=dotnet:3 bash -c "$(curl -L https://install.datadoghq.com/scripts/install_script_agent7.sh)"

Select what type of errors to track

Copied!
1
npm i @datadog/browser-rum
Copied!
1
2
3
4
5
6
7
8
9
10
11
12
import { datadogRum } from '@datadog/browser-rum';

datadogRum.init({
  applicationId: '<APP_ID>',
  clientToken: '<CLIENT_TOKEN>',
  service: '<SERVICE>',
  env: '<ENV_NAME>',
  site: '<SITE>',
  // version: '1.0.0',
  trackUserInteractions: true,
  trackResources: true,
});
Copied!
1
npm install @datadog/browser-rum @datadog/browser-rum-react
Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
import { datadogRum } from '@datadog/browser-rum';
import { reactPlugin } from '@datadog/browser-rum-react';

datadogRum.init({
  applicationId: '<APP_ID>',
  clientToken: '<CLIENT_TOKEN>',
  service: '<SERVICE>',
  env: '<ENV_NAME>',
  site: '<SITE>',
  // version: '1.0.0',
  trackUserInteractions: true,
  trackResources: true,
  plugins: [reactPlugin({ router: true })],
});
Copied!
1
2
3
4
5
6
plugins {
    id("com.datadoghq.dd-sdk-android-gradle-plugin") version "<latest_version>"
}
dependencies {
    implementation "com.datadoghq:dd-sdk-android-rum:<latest_version>"
}
Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class SampleApplication : Application() {
    override fun onCreate() {
        super.onCreate()

        val clientToken = "<CLIENT_TOKEN>"
        val environmentName = "<ENV_NAME>"
        val appVariantName = "<APP_VARIANT_NAME>"

        val configuration = Configuration.Builder(
            clientToken = clientToken,
            env = environmentName,
            variant = appVariantName
        )
            .useSite(DatadogSite.US1)
            .build()
        Datadog.initialize(this, configuration, trackingConsent)

        val applicationId = "<APP_ID>"
        val rumConfiguration = RumConfiguration.Builder(applicationId)
            .trackUserInteractions()
            .useViewTrackingStrategy(strategy)
            .build()
        Rum.enable(rumConfiguration)
      NdkCrashReports.enable()
    }
}
Copied!
1
.package(url: "https://github.com/Datadog/dd-sdk-ios.git", .upToNextMajor(from: "2.0.0"))
Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import DatadogCore
import DatadogRUM
import DatadogCrashReporting

let appID = "<APP_ID>",
let clientToken = "<CLIENT_TOKEN>",
let environment = "<ENV_NAME>"
let service: "<service name>"

Datadog.initialize(
    with: Datadog.Configuration(
        clientToken: clientToken,
        env: environment,
   service: service
    ),
    trackingConsent: .granted
)

RUM.enable(
    with: RUM.Configuration(
        applicationID: appID,
        uiKitViewsPredicate: DefaultUIKitRUMViewsPredicate(),
        uiKitActionsPredicate: DefaultUIKitRUMActionsPredicate(),
 urlSessionTracking: RUM.Configuration.URLSessionTracking(),
 appHangThreshold: 0.25,
 trackWatchdogTerminations: true
    )
)


CrashReporting.enable()
Copied!
1
2
npm install @datadog/mobile-react-native
(cd ios && pod install)
Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import {
    BatchSize,
    DatadogProvider,
    DatadogProviderConfiguration,
    SdkVerbosity,
    UploadFrequency,
} from "@datadog/mobile-react-native";


const config = new DatadogProviderConfiguration(
    "<CLIENT_TOKEN>",
    "<ENV_NAME>",
    "30bb1c1b-b33b-4ed3-a5cc-70bd6f859228",
    true, // track user interactions (such as a tap on buttons).
    true, // track XHR Resources
    true // track Errors
)

config.nativeCrashReportEnabled = true
config.resourceTracingSamplingRate = 0;


// Wrap the content of your App component by a DatadogProvider component, passing it your configuration:
export default function App() {
    return (
        <DatadogProvider configuration={config}>
            <Navigation />
        </DatadogProvider>
    );
}
Copied!
1
2
dependencies:
  datadog_flutter_plugin: x.x.x
Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
final configuration = DatadogConfiguration(
  clientToken: 'pub8374a84c982012aeb74ba08a5ec91bb0',
  env: '<ENV_NAME>',
  site: DatadogSite.us1,
  nativeCrashReportEnabled: true,
  loggingConfiguration: DatadogLoggingConfiguration(),
  rumConfiguration: DatadogRumConfiguration(
    applicationId: '4115a060-e4eb-4f2e-8618-730d2d701770',
  ),
  firstPartyHosts: ['example.com'],

)..enableHttpTracking();

await DatadogSdk.runApp(configuration, TrackingConsent.granted, () async {
  runApp(MyApp());
});


RumUserActionDetector(
  rum: DatadogSdk.instance.rum,
  child: Scaffold(
    appBar: AppBar(
      title: const Text('RUM'),
    ),
    body: // Rest of your application
  ),
);
Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
sub RunUserInterface(args as dynamic)
    screen = CreateObject("roSGScreen")
    scene = screen.CreateScene("MyScene")
    screen.show()

    datadogroku_initialize({
        clientToken: "pub51f1a2be549cd82c034784c7d7d46548",
        applicationId: "f7f66b08-cbf3-4c94-b3ab-2ece1b759b9f"
        site: "us1",
        env: "<ENV_NAME>",
        sessionSampleRate: 100, ' the percentage (integer) of sessions to track
        launchArgs: args
    })
end sub
Copied!
1
npm i @datadog/browser-rum
Copied!
1
2
3
4
5
6
7
8
9
10
11
12
import { datadogRum } from '@datadog/browser-rum';

datadogRum.init({
   applicationId: '<APP_ID>',
   clientToken: '<CLIENT_TOKEN>',
   service: '<SERVICE>',
   env: '<ENV_NAME>',
   site: '<SITE>',
   // version: '1.0.0',
   trackUserInteractions: true,
   trackResources: true,
});
Copied!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
// in common source set
fun initializeDatadog(context: Any? = null) {

    // context should be application context on Android and can be null on iOS
    val appClientToken = "<CLIENT_TOKEN>"
    val appEnvironment = "<ENV_NAME>"
    

    val configuration = Configuration.Builder(
            clientToken = appClientToken,
            env = appEnvironment,
            
    )
        .trackCrashes(true)
        .build()

    Datadog.initialize(context, configuration, trackingConsent)

    val applicationId = "<APP_ID>"
    val rumConfiguration = RumConfiguration.Builder(applicationId)
            // platform specific setup
            .apply {
                datadogPlatformSetup(this)
            }
            .build()

    Rum.enable(rumConfiguration)
}

internal expect fun datadogPlatformSetup(rumConfigurationBuilder: RumConfiguration.Builder)

// in iOS source set
internal actual fun datadogPlatformSetup(rumConfigurationBuilder: RumConfiguration.Builder) {
    with(rumConfigurationBuilder) {
        trackUiKitViews()
        trackUiKitActions()
        // check more iOS-specific methods
    }
}

// in Android source set
internal actual fun datadogPlatformSetup(rumConfigurationBuilder: RumConfiguration.Builder) {
    with(rumConfigurationBuilder) {
        useViewTrackingStrategy(//choose view tracking strategy//)
        trackUserInteractions()
        // check more Android-specific methods
    }
}
Copied!
1
2
3
DD_API_KEY=<API_KEY> DD_SITE="datadoghq.com" DD_APM_INSTRUMENTATION_ENABLED=host
DD_APM_ERROR_TRACKING_STANDALONE=true
DD_APM_INSTRUMENTATION_LIBRARIES=java:1 bash -c "$(curl -L https://install.datadoghq.com/scripts/install_script_agent7.sh)"
Copied!
1
2
3
DD_API_KEY=<API_KEY> DD_SITE="datadoghq.com" DD_APM_INSTRUMENTATION_ENABLED=host
DD_APM_ERROR_TRACKING_STANDALONE=true
DD_APM_INSTRUMENTATION_LIBRARIES=python:3 bash -c "$(curl -L https://install.datadoghq.com/scripts/install_script_agent7.sh)"
Copied!
1
2
3
DD_API_KEY=<API_KEY> DD_SITE="datadoghq.com" DD_APM_INSTRUMENTATION_ENABLED=host
DD_APM_ERROR_TRACKING_STANDALONE=true
DD_APM_INSTRUMENTATION_LIBRARIES=ruby:2 bash -c "$(curl -L https://install.datadoghq.com/scripts/install_script_agent7.sh)"
Copied!
1
2
3
DD_API_KEY=<API_KEY> DD_SITE="datadoghq.com" DD_APM_INSTRUMENTATION_ENABLED=host
DD_APM_ERROR_TRACKING_STANDALONE=true
DD_APM_INSTRUMENTATION_LIBRARIES=js:5 bash -c "$(curl -L https://install.datadoghq.com/scripts/install_script_agent7.sh)"
Copied!
1
2
3
DD_API_KEY=<API_KEY> DD_SITE="datadoghq.com" DD_APM_INSTRUMENTATION_ENABLED=host
DD_APM_ERROR_TRACKING_STANDALONE=true
DD_APM_INSTRUMENTATION_LIBRARIES=php:1 bash -c "$(curl -L https://install.datadoghq.com/scripts/install_script_agent7.sh)"
Copied!
1
2
3
DD_API_KEY=<API_KEY> DD_SITE="datadoghq.com" DD_APM_INSTRUMENTATION_ENABLED=host
DD_APM_ERROR_TRACKING_STANDALONE=true
DD_APM_INSTRUMENTATION_LIBRARIES=dotnet:3 bash -c "$(curl -L https://install.datadoghq.com/scripts/install_script_agent7.sh)"

Error Tracking supports 10+ languages and frameworks

typescript.svg
android.svg
go.svg
flutter.svg
ios.svg
cplusplus.svg
react.svg
javascript.svg
java.svg
net.svg
node.svg
FAQ

Frequently Asked Questions

What is Datadog Error Tracking?
Datadog Error Tracking provides a single source of truth for errors across frontend and backend systems, automatically grouping similar errors and correlating them with relevant logs, traces and RUM events to help developers quickly identify, prioritize, and resolve issues.
Do I need to modify my code to use Error Tracking?
No, Error Tracking works seamlessly with existing Datadog telemetry data from RUM and APM without requiring code modifications or additional SDK configuration.
How does Datadog Error Tracking help prioritize critical errors?
Error Tracking automatically groups similar errors based on type, message, and stack trace, assigns suspected cause labels, and surfaces the most critical issues first to reduce alert fatigue and help teams focus on high-impact failures.
What are Session Replays and how do they help with debugging?
Session Replays capture the user’s journey 15 seconds before and after a frontend error occurs, providing visual context that eliminates the need for manual reproduction and accelerates the debugging process.
What is Exception Replay?
Exception Replay automatically captures local variable data and execution context at the time a backend exception occurs in production, providing deep visibility into failures and eliminating guesswork during debugging.
How does Error Tracking detect regressions?
Error Tracking’s regression detection continuously monitors error trends throughout an application’s life cycle, automatically detecting recurring issues and reopening them with preserved historical context to help teams correlate regressions with specific deployments or infrastructure changes.
Can I set up alerts for critical errors?
Yes, you can configure real-time alerts for new, or high-impact issues and route them to on-call engineers through Datadog On-Call or third-party tools.
Does Error Tracking work across both frontend and backend?
Yes, Error Tracking provides full-stack visibility, connecting errors across the entire stack including frontend UI, backend services, and mobile apps in one centralized platform.
Can I assign errors to my team or integrate with issue trackers?
Yes, Datadog Error Tracking integrates with Jira.