# Loader Script | Sentry for Solid

The Loader Script is the easiest way to initialize the Sentry SDK. The Loader Script also automatically keeps your Sentry SDK up to date and offers configuration for different Sentry features.

## [Using the Loader](https://docs.sentry.io/platforms/javascript/guides/solid/install/loader.md#using-the-loader)

To use the loader, go in the Sentry UI to **Settings > Projects > (select project) > SDK Setup > Loader Script**. Copy the script tag and include it as the first script on your page. By including it first, you allow it to catch and buffer events from any subsequent scripts, while still ensuring the full SDK doesn't load until after everything else has run.

```html
<script
  src="https://js.sentry-cdn.com/___PUBLIC_KEY___.min.js"
  crossorigin="anonymous"
></script>
```

By default, Tracing and Session Replay are disabled.

## [Source Maps](https://docs.sentry.io/platforms/javascript/guides/solid/install/loader.md#source-maps)

To have correct stack traces for minified asset files when using the Loader Script, you will have to either [host your Source Maps publicly](https://docs.sentry.io/platforms/javascript/sourcemaps/uploading/hosting-publicly.md) or [upload them to Sentry](https://docs.sentry.io/platforms/javascript/sourcemaps.md).

## [Loader Configuration](https://docs.sentry.io/platforms/javascript/guides/solid/install/loader.md#loader-configuration)

The loader has a few configuration options:

* What version of the SDK to load
* Using Tracing
* Using Session Replay
* Enabling SDK debugging

### [SDK Version](https://docs.sentry.io/platforms/javascript/guides/solid/install/loader.md#sdk-version)

To configure the version, use the dropdown in the "Loader Script" settings, directly beneath the script tag you copied earlier.

Note that because of caching, it can take a few minutes for version changes made here to take effect.

### [Load Timing](https://docs.sentry.io/platforms/javascript/guides/solid/install/loader.md#load-timing)

If you only use the Loader for errors, the loader won't load the full SDK until triggered by one of the following:

* an unhandled error
* an unhandled promise rejection
* a call to `Sentry.captureException`
* a call to `Sentry.captureMessage`
* a call to `Sentry.captureEvent`

Once one of those occurs, the loader will buffer that event and immediately request the full SDK from our CDN. Any events that occur between that request being made and the completion of SDK initialization will also be buffered, and all buffered events will be sent to Sentry once the SDK is fully initialized.

Alternatively, you can set the loader to request the full SDK earlier: still as part of page load, but *after* all of the other JavaScript on the page has run. (In other words, in a subsequent event loop.) To do this, include `data-lazy="no"` in your script tag.

```html
<script
  src="https://js.sentry-cdn.com/___PUBLIC_KEY___.min.js"
  crossorigin="anonymous"
  data-lazy="no"
></script>
```

Finally, if you want to control the timing yourself, you can call `Sentry.forceLoad()`. You can do this as early as immediately after the loader runs (which has the same effect as setting `data-lazy="no"`) and as late as the first unhandled error, unhandled promise rejection, or call to `Sentry.captureMessage` or `Sentry.captureEvent` (which has the same effect as not calling it at all). Note that you can't delay loading past one of the aforementioned triggering events.

If Tracing and/or Session Replay is enabled, the SDK will immediately fetch and initialize the bundle to make sure it can capture transactions and/or replays once the page loads.

## [SDK Configuration](https://docs.sentry.io/platforms/javascript/guides/solid/install/loader.md#sdk-configuration)

While the Loader Script will work out of the box without any configuration in your application, you can still configure the SDK according to your needs.

### [Default Configuration](https://docs.sentry.io/platforms/javascript/guides/solid/install/loader.md#default-configuration)

For Tracing, the SDK will be initialized with `tracesSampleRate: 1` by default. This means that the SDK will capture all traces.

For Session Replay, the defaults are `replaysSessionSampleRate: 0.1` and `replaysOnErrorSampleRate: 1`. This means Replays will be captured for 10% of all normal sessions and for all sessions with an error.

### [Release Configuration](https://docs.sentry.io/platforms/javascript/guides/solid/install/loader.md#release-configuration)

You can configure the release by adding the following to your page:

```html
<script>
  window.SENTRY_RELEASE = {
    id: "...",
  };
</script>
```

### [Custom Configuration](https://docs.sentry.io/platforms/javascript/guides/solid/install/loader.md#custom-configuration)

The loader script always includes a call to `Sentry.init` with a default configuration, including your DSN. If you want to [configure your SDK](https://docs.sentry.io/platforms/javascript/guides/solid/configuration/options.md) beyond that, you can configure a custom init call by defining a `window.sentryOnLoad` function. Whatever is defined inside of this function will *always* be called first, before any other SDK method is called.

**Be sure to define this function *before* you add the loader script, to ensure it can be called at the right time:**

```html
<script>
  // Configure sentryOnLoad before adding the Loader Script
  window.sentryOnLoad = function () {
    Sentry.init({
      // add custom config here
    });
  };
</script>

<script
  src="https://js.sentry-cdn.com/___PUBLIC_KEY___.min.js"
  crossorigin="anonymous"
></script>
```

Inside of the `window.sentryOnLoad` function, you can configure a custom `Sentry.init()` call. You can configure your SDK exactly the way you would if you were using the CDN, with one difference: your `Sentry.init()` call doesn't need to include your DSN, since it's already been set. Inside of this function, the full Sentry SDK is guaranteed to be loaded & available.

```html
<script>
  // Configure sentryOnLoad before adding the Loader Script
  window.sentryOnLoad = function () {
    Sentry.init({
      release: " ... ",
      environment: " ... "
    });
    Sentry.setTag(...);
    // etc.
  };
</script>
```

### [Guarding SDK Function Calls](https://docs.sentry.io/platforms/javascript/guides/solid/install/loader.md#guarding-sdk-function-calls)

By default, the loader will make sure you can call these functions directly on `Sentry` at any time, even if the SDK is not yet loaded:

* `Sentry.captureException()`
* `Sentry.captureMessage()`
* `Sentry.captureEvent()`
* `Sentry.addBreadcrumb()`
* `Sentry.withScope()`
* `Sentry.showReportDialog()`

If you want to call any other method when using the Loader, you have to guard it with `Sentry.onLoad()`. Any callback given to `onLoad()` will be called either immediately (if the SDK is already loaded), or later once the SDK has been loaded:

```html
<script>
  window.sentryOnLoad = function () {
    Sentry.init({
      // ...
    });
  };
</script>

<script
  src="https://js.sentry-cdn.com/___PUBLIC_KEY___.min.js"
  crossorigin="anonymous"
></script>

<script>
  // Guard against window.Sentry not being available, e.g. due to Ad-blockers
  window.Sentry &&
    Sentry.onLoad(function () {
      // Inside of this callback,
      // we guarantee that `Sentry` is fully loaded and all APIs are available
      const client = Sentry.getClient();
      // do something custom here
    });
</script>
```

## [Limitations of Errors-only Capturing](https://docs.sentry.io/platforms/javascript/guides/solid/install/loader.md#limitations-of-errors-only-capturing)

When using the Loader Script with just errors, the script injects the SDK asynchronously. This means that only *unhandled errors* and *unhandled promise rejections* will be caught and buffered before the SDK is fully loaded. Specifically, capturing [breadcrumb data](https://docs.sentry.io/platforms/javascript/guides/solid/enriching-events/breadcrumbs.md) will not be available until the SDK is fully loaded and initialized. To reduce the amount of time these features are unavailable, set `data-lazy="no"` or call `forceLoad()` as described above.

If you want to understand the inner workings of the loader itself, you can read the documented source code in all its glory over at the [Sentry repository](https://github.com/getsentry/sentry/blob/master/src/sentry/templates/sentry/js-sdk-loader.ts).

## [Limitations of Tracing](https://docs.sentry.io/platforms/javascript/guides/solid/install/loader.md#limitations-of-tracing)

Because the loader script injects the actual SDK asynchronously to keep your pageload performance high, the SDK's tracing functionality is only available once the SDK is loaded and initialized. This means that if you e.g. have `fetch` calls right at the beginning of your application, they might not be traced. If this is a critical issue for you, you have two options to ensure that all your `fetch` calls are traced:

* Initialize the SDK in `window.sentryOnLoad` as described in [Custom Configuration](https://docs.sentry.io/platforms/javascript/guides/solid/install/loader.md#custom-configuration). Then make your `fetch` call in the `Sentry.onload` callback.

  <!-- -->

  Example

  ```html
  <script>
    window.sentryOnLoad = function () {
      Sentry.init({
        // ...
      });
    };
  </script>

  <script
    src="https://js.sentry-cdn.com/___PUBLIC_KEY___.min.js"
    crossorigin="anonymous"
  ></script>

  <script>
    Sentry.onLoad(function () {
      fetch("/api/users");
    });
  </script>
  ```

* Use the [CDN bundles](https://docs.sentry.io/platforms/javascript/guides/solid/install/loader.md#cdn) instead of the Loader Script. This will ensure that the SDK is loaded synchronously, and that all your `fetch` calls are traced.

Please be aware that both of these options will add delay to your `fetch` calls or decrease your pageload performance. Ultimately, this is the trade-off between lazy and eagerly loading the Sentry SDK.

## [CDN](https://docs.sentry.io/platforms/javascript/guides/solid/install/loader.md#cdn)

Sentry supports loading the JavaScript SDK from a CDN. Generally we suggest using our Loader instead. If you *must* use a CDN, see [Available Bundles](https://docs.sentry.io/platforms/javascript/guides/solid/install/loader.md#available-bundles) below.

## [Full Bundle](https://docs.sentry.io/platforms/javascript/guides/solid/install/loader.md#full-bundle)

To use all Sentry features, including error monitoring, tracing, [Session Replay](https://docs.sentry.io/platforms/javascript/guides/solid/session-replay.md), and [User Feedback](https://docs.sentry.io/platforms/javascript/guides/solid/user-feedback.md), you can use the following bundle:

```html
<script
  src="https://browser.sentry-cdn.com/10.34.0/bundle.tracing.replay.feedback.min.js"
  integrity="sha384-CAHKD+iVVYrZ+E8QuIibE+N3f/rmoYs274EUbsrnDpb32tkiEk8ka+Fzn6ik4IiJ"
  crossorigin="anonymous"
></script>
```

## [Performance Bundle](https://docs.sentry.io/platforms/javascript/guides/solid/install/loader.md#performance-bundle)

To use Sentry for error and tracing, you can use the following bundle:

```html
<script
  src="https://browser.sentry-cdn.com/10.34.0/bundle.tracing.min.js"
  integrity="sha384-XajL8SwtDN/LRM3gIN+prHLKIew0luviWh+480mINja6MDoSm0xuOXAKdOzbSW4i"
  crossorigin="anonymous"
></script>
```

## [Performance & Replay Bundle](https://docs.sentry.io/platforms/javascript/guides/solid/install/loader.md#performance--replay-bundle)

To use Sentry for error and tracing, as well as for [Session Replay](https://docs.sentry.io/platforms/javascript/guides/solid/session-replay.md), you can use the following bundle:

```html
<script
  src="https://browser.sentry-cdn.com/10.34.0/bundle.tracing.replay.min.js"
  integrity="sha384-rJY0/sNTE7SVTEbo+NUvBhoZk48wY0R4wIgwnuB7KFNi4oXtvqP7VMNJuLb1dtRZ"
  crossorigin="anonymous"
></script>
```

## [Errors & Replay Bundle](https://docs.sentry.io/platforms/javascript/guides/solid/install/loader.md#errors--replay-bundle)

To use Sentry for error monitoring, as well as for [Session Replay](https://docs.sentry.io/platforms/javascript/guides/solid/session-replay.md), but **not for tracing**, you can use the following bundle:

```html
<script
  src="https://browser.sentry-cdn.com/10.34.0/bundle.replay.min.js"
  integrity="sha384-oDTLita/jJbBDNW4bLzp1/neaAtArWJ5yUAPEbjr9wcJOOII+60f5PFl7uNc1vXi"
  crossorigin="anonymous"
></script>
```

## [Errors-only Bundle](https://docs.sentry.io/platforms/javascript/guides/solid/install/loader.md#errors-only-bundle)

If you only use Sentry for error monitoring, you can use the following bundle:

```html
<script
  src="https://browser.sentry-cdn.com/10.34.0/bundle.min.js"
  integrity="sha384-qsLq5yTjw6ik15tVn8O38D9yevkMDDicKZ5E/tXYMOFKksEtprtlotkH7gxMSvsh"
  crossorigin="anonymous"
></script>
```

## [Usage & Configuration](https://docs.sentry.io/platforms/javascript/guides/solid/install/loader.md#usage--configuration)

Once you've included the Sentry SDK bundle in your page, you can use Sentry in your own bundle:

```javascript
Sentry.init({
  dsn: "___PUBLIC_DSN___",
  // this assumes your build process replaces `process.env.npm_package_version` with a value
  release: "my-project-name@" + process.env.npm_package_version,
  integrations: [
    // If you use a bundle with tracing enabled, add the BrowserTracing integration
    Sentry.browserTracingIntegration(),
    // If you use a bundle with session replay enabled, add the Replay integration
    Sentry.replayIntegration(),
  ],

  // We recommend adjusting this value in production, or using tracesSampler
  // for finer control
  tracesSampleRate: 1.0,

  // Set `tracePropagationTargets` to control for which URLs distributed tracing should be enabled
  tracePropagationTargets: ["localhost", /^https:\/\/yourserver\.io\/api/],
});
```

## [Available Bundles](https://docs.sentry.io/platforms/javascript/guides/solid/install/loader.md#available-bundles)

Our CDN hosts a variety of bundles:

* `bundle.<modifiers>.js` is `@sentry/browser` with error monitoring only
* `bundle.tracing.<modifiers>.js` is `@sentry/browser` with error and tracing
* `bundle.replay.<modifiers>.js` is `@sentry/browser` with error and session replay
* `bundle.feedback.<modifiers>.js` is `@sentry/browser` with error and user feedback
* `bundle.tracing.replay.<modifiers>.js` is `@sentry/browser` with error, tracing and session replay
* `bundle.tracing.replay.feedback.<modifiers>.js` is `@sentry/browser` with error, tracing, session replay and user feedback

Additionally, each of the integrations in `@sentry/integrations` is available as a bundle named `<integration-name>.<modifiers>.js`.

Since v8 of the SDK, the bundles are ES6 by default. If you need ES5 support, make sure to add a polyfill for ES5 features yourself. Alternatively, you can use the v7 bundles and add the `.es5` modifier.

Each version has three bundle varieties:

* minified (`.min`)
* unminified (no `.min`), includes debug logging
* minified with debug logging (`.debug.min`)

Bundles that include debug logging output more detailed log messages, which can be helpful for debugging problems. Make sure to [enable debug](https://docs.sentry.io/platforms/javascript/guides/solid/configuration/options.md#debug) to see debug messages in the console. Unminified and debug logging bundles have a greater bundle size than minified ones.

For example:

* `bundle.js` is `@sentry/browser`, compiled to ES6 but not minified, with debug logging included (as it is for all unminified bundles)
* `bundle.tracing.debug.min.js` is `@sentry/browser` with tracing enabled, minified, with sdk debug logging included

| File                                        | Integrity Checksum                                                        |
| ------------------------------------------- | ------------------------------------------------------------------------- |
| browserprofiling.debug.min.js               | `sha384-RfFjaUuRHthKi7ZUumEhJwzp3l4QBf4kmzPEcH18I/XO5cqMM9/6SqGB0u0ylkTx` |
| browserprofiling.js                         | `sha384-qF9tlc1FoiSvIZJWgwsyx5wDCFk3o1pRnLqgf54TNbrGnX5MMysTLNwbRNcgi4KS` |
| browserprofiling.min.js                     | `sha384-ZbmQpBosGeJX1AHKTPAUJ0aT9OUTL4Rat8PRmQdFHbuJ7v0m0VE6FuGkSAVgYqwu` |
| bundle.debug.min.js                         | `sha384-cLcpY9jsRJiS6kBUg48yIW6zKBth2qgIDiZqWs2RcQ6Z3F9YD0sJX5AeyKMYiGZN` |
| bundle.feedback.debug.min.js                | `sha384-sOOMhTAOZQfUCk5UbSvEOX/qo2ci5N7Ue7HXI2/+PHAFgR6SPm9UDrzv9Yvh+BaU` |
| bundle.feedback.js                          | `sha384-/hY0IriuuGb4PB5ODCzsCztbsO6S1M4CDFt8hHcIY5UtwHjvZynL46Y/P8FFTK6g` |
| bundle.feedback.min.js                      | `sha384-NBmdYBtzzlGPpCgQO1hhLCQqxHxgw/3LJce/tIjThB9sQ4BjevhwKiLMRbnWcIKM` |
| bundle.js                                   | `sha384-wIUxcZaFjNLL9Eml5UeB7lB3BjYDtBwbubxgEmkOWeo6qY0WAN1CIsSt86gxjv06` |
| bundle.min.js                               | `sha384-qsLq5yTjw6ik15tVn8O38D9yevkMDDicKZ5E/tXYMOFKksEtprtlotkH7gxMSvsh` |
| bundle.replay.debug.min.js                  | `sha384-LOKn9FANyPzr3PlUtaJtXDnCx/w+dad1ZMpYCsCRqU6J/jJSZuRhiern3AlUz3JF` |
| bundle.replay.feedback.debug.min.js         | `sha384-suhG1C2IGtZasXFOSN3YjzuQgrxgUynL5Ym5TcLcJ/m89UlIgXcUTkbsdcGoDxSR` |
| bundle.replay.feedback.js                   | `sha384-mHIlyMFXcOYIG9S5MUFsZu8TD4CJ1c+qNKBtlz36GPcdVsIawQ4dqNK/nyaNTkuB` |
| bundle.replay.feedback.min.js               | `sha384-XhIam9d+2QNz4eAXvQV9CRvLtZkkSxHaf7Aio+7vawRHyS8y7cUF/02l30EjCp2K` |
| bundle.replay.js                            | `sha384-Yvxd/hmT+TQX9WvghWULr0EcvlCxThGcURRQS2vJ1XxNd/otAmFaXAETpFFTy8l2` |
| bundle.replay.min.js                        | `sha384-oDTLita/jJbBDNW4bLzp1/neaAtArWJ5yUAPEbjr9wcJOOII+60f5PFl7uNc1vXi` |
| bundle.tracing.debug.min.js                 | `sha384-RBYgmizSw5uAwaDF/mpJybIC+gkOli4SQeZFPKyKS7iGTFDyE6elAJO6ngqdtGHS` |
| bundle.tracing.js                           | `sha384-EHLcWAWNroZuAZ89SnLtqJUjFKGe6qnn9Wr1AAV/q0zYfktjnm0OZ20Gy/F/wzxw` |
| bundle.tracing.logs.metrics.debug.min.js    | `sha384-o+klfkYiibw1NFJZJbdjXuByzEAyMVa8v47JjpaQK39QX3qrmNNMuNaZ6WegUnL4` |
| bundle.tracing.logs.metrics.js              | `sha384-InWylUru5xJqA4xIbGuCa7CpHHQEbBQQCFBxPV5o5TPwqJMzRblARnGZpfkzbsS/` |
| bundle.tracing.logs.metrics.min.js          | `sha384-XUK2CSbY7ofhR6lQs0ov9F15UNEQ5mLpJjEQuPWAsnhQOAEzKkVdwHO1W+NI660Q` |
| bundle.tracing.min.js                       | `sha384-XajL8SwtDN/LRM3gIN+prHLKIew0luviWh+480mINja6MDoSm0xuOXAKdOzbSW4i` |
| bundle.tracing.replay.debug.min.js          | `sha384-yC1LWOnITUXgFXlbBbKMcu2AxNvGuD0UGrBguBzdP9TVrEg/nN5EzULYnU2sVV1U` |
| bundle.tracing.replay.feedback.debug.min.js | `sha384-S3kwhX8xmkrwv1nviW6hV8KX1aSqFn32sLhTxB7PaiI1jR/3oAAm+P8HBHirr9sw` |
| bundle.tracing.replay.feedback.js           | `sha384-Eiut/UdrZs0tfUNKDthax9S2So8llV4p92NBS4RxRrQ4F3MDc4oXrsuVE3I8y3T2` |
| bundle.tracing.replay.feedback.min.js       | `sha384-CAHKD+iVVYrZ+E8QuIibE+N3f/rmoYs274EUbsrnDpb32tkiEk8ka+Fzn6ik4IiJ` |
| bundle.tracing.replay.js                    | `sha384-/DPOSdcxpZpyGTV6p9YofM5sm5RiMYZBn8RQ0NnStBtKWp+jxVLUT6SjvbMYnrtJ` |
| bundle.tracing.replay.min.js                | `sha384-rJY0/sNTE7SVTEbo+NUvBhoZk48wY0R4wIgwnuB7KFNi4oXtvqP7VMNJuLb1dtRZ` |
| captureconsole.debug.min.js                 | `sha384-Fab7ovp2P4oiCU1jcrodMgFCD/1OYhlssF3Mo5umnyvwk/BzZbUJIi551A2wqAw0` |
| captureconsole.js                           | `sha384-7btvej8/KCYxvcqxKB1XwF2HfgVhP0EN2ktMYVXYNOI41dW1kW0kxzsvQ/eJK4r0` |
| captureconsole.min.js                       | `sha384-bLcawPzO+FkKgQGVGLz5irXRxnNApitVxy5CdWXnJ+eevp4fhoefzbXozmCK7M7y` |
| contextlines.debug.min.js                   | `sha384-M5LZ/mvHbKWQMS9sb3mcDAH6UymTqap8b5XBKh/MbCRyCecIntu3NZRbj3fHK+8/` |
| contextlines.js                             | `sha384-5kt5L+kynIs4ext3Yqk/S0h/1cQiFmDN4Caz+Ni8mCAj4ev2q39toLdJ+06dr5KA` |
| contextlines.min.js                         | `sha384-45dzt0cz+x5k4agq7LLSy0OWZD8zjGV8pL4LjmcYlibeOw0NGL5eTcfvV9t71GPm` |
| createlangchaincallbackhandler.debug.min.js | `sha384-ekBgdaGTo2nDW4xCq3wtB/LbYEiI863ZkkwlGRT7tE8zDUR5U9EKhKc96zI+j0w0` |
| createlangchaincallbackhandler.js           | `sha384-K6ykAKwUmb7f5b7SVL7RJcgwdRg7ZtS5ihNuTY+hcRSZWzQoG6z3rgGvrSbletwF` |
| createlangchaincallbackhandler.min.js       | `sha384-mpF3hdCjp9ZjwQMUs4swOH14KSdAIa5V/vkzbSdd0X0N9lMlgc4TWb0CQSLRIvC2` |
| dedupe.debug.min.js                         | `sha384-VhQdvA3vk7KfDxCy66fzeM5Qgl+4Pc64P4p02IBSN2xzSgq4eMFUl/Ep/s9AhOm4` |
| dedupe.js                                   | `sha384-AvHw/3sJHBXlWf4eheCs0RVC69qPRLSrv8oiAzzOsnP74L83YrjlylDHH0DvkPYJ` |
| dedupe.min.js                               | `sha384-LsaCE0Db3gYpEJBz/ntRzbL61fAKghI4w6fTWSla7xpqYRKLyYAUYNrkpIoBjAeF` |
| extraerrordata.debug.min.js                 | `sha384-04LFTGUvgmy+MXuGX7+ElWmoF96hEU7BA2Tr7Ak05encfRl8aHifVveTfh2LGmu4` |
| extraerrordata.js                           | `sha384-YLIew6jQpHXCsKRfzwj+3uw5apWH6Iqf8/mjyO3afGrUJuSacy1XIKEKt2V0Z1pZ` |
| extraerrordata.min.js                       | `sha384-EHfW0ACPdFJPyJ3pfOEZrXBpg6770lE9ueRrqo4bK5B8+aOwlVU9HS2q4Vvjp1m8` |
| feedback-modal.debug.min.js                 | `sha384-nTc4t3oX+OJuK1pYyIoKH8z7ipMxyqf9vUkiMHMKqaYqKK+5Ra1pZhq7nqoywy7X` |
| feedback-modal.js                           | `sha384-9df8Ge7CsvVlpDFWScEfB02uWMwSmUqpcQCIpuGOX0BWzaW7XOalBA38C9Asd12e` |
| feedback-modal.min.js                       | `sha384-ph3jOariE9B6oc2eXH2ZQ4TQX977KaQvM//+DDDvFVWkWSSMSLo+nhPYTVQ2I/hz` |
| feedback-screenshot.debug.min.js            | `sha384-7jIR8ryflkdXXRkXG7OLEUPX/Pfsk8pVJFQiY7A4mDd5fLoIsj0cK8L6YqgYIf+E` |
| feedback-screenshot.js                      | `sha384-U7bY0U9g9PFp2B9Ybiiaa/XkykE+jnAQaNBaKObhCw29wd/IIEtAL4q+zx1FDfmb` |
| feedback-screenshot.min.js                  | `sha384-D7cVBcyQTgoFR+eTpRsnko5gsFR3i1rVfwlgmbp9KVjO0GlBF+yGzJFjCSAC9ACD` |
| feedback.debug.min.js                       | `sha384-fA2rPb5l+QdoeVwU16QRU8RAtHxbroQDs85xsMQxAXVWmQu+s/bkym50n3GWtUgJ` |
| feedback.js                                 | `sha384-ALgrSFgh3cbWW7grT4HLE3VFltKCE5zMJPjU3sctS2aD7MDxow6zjP7Ud0x4RfII` |
| feedback.min.js                             | `sha384-5weGaV1ffxf1k/3bJxemi2wtDcVXLci01my7lTZ+agEPher8AFuFSrLK012izYXv` |
| graphqlclient.debug.min.js                  | `sha384-fA2XpAdWPwwA68IT3q4O3Hx7S8NcIH16p1grGaL8PKeQi7xQYmcy/88mtNuZ41yk` |
| graphqlclient.js                            | `sha384-xO97ggMl9QC3NJuaSYEm6LGH3jEuj84Uw8PY4seFnC3cx057jWbv1+IcIpjz4OzC` |
| graphqlclient.min.js                        | `sha384-hcXo4IpD/1dNYVudsqJsywAxTzmfDeOb4XlnnS0lbRvi9QALwXog4OIHrcbhLIIb` |
| httpclient.debug.min.js                     | `sha384-vhpqb6ZCiIgDGbniykTDeRWDoipeap6ekY8oeQhvzFQd1Nqq61JlfL2oJK44TPFY` |
| httpclient.js                               | `sha384-coU/RhqDOBvCSrA3QZ4UWEFJqBvA8Zkph7EXfwCpT9ZFvKEEbgU9KCqtNZmwTZdD` |
| httpclient.min.js                           | `sha384-2bzyy43FWZ2yLow5YElneZc9iLEKGJABI9MsLqcP//CJ3ohQx8TM3txpokKp+np9` |
| instrumentanthropicaiclient.debug.min.js    | `sha384-LoS1udXJwpthk18tKoLeodGvTc37KJzeBE91ujJrszs4gLs8z8qUdE/j0vmJ9jiP` |
| instrumentanthropicaiclient.js              | `sha384-KKG17XmrpF2wjzehDQ2s2fe6CvzB1TnBFk/SsLfcYCybWYdwykqQ7/U9fG4+THWl` |
| instrumentanthropicaiclient.min.js          | `sha384-3SVVqpggN9Ml/WpmIVWQTAWtDDkuA0+vnlpOSj0m821r6ZIQ8EfESx0kjlzBN5s/` |
| instrumentgooglegenaiclient.debug.min.js    | `sha384-Qo/14TyyrA8hBCUSdP46++frKn+qHW0Wv6Q4SF2dydsO9iZzSr6JXFa/Am7RexaC` |
| instrumentgooglegenaiclient.js              | `sha384-N5wG6GMF8eO5N1z8lL16X4rNEuTv3ZhyOGWkX51UO9SfNckjLygalcDFcnqy/cB/` |
| instrumentgooglegenaiclient.min.js          | `sha384-QEb50uB/vZV9gKWkTyHXfBVwSM10/eMRt3kFfvVIoPnq7UccAxTUZx94WHESBlq8` |
| instrumentlanggraph.debug.min.js            | `sha384-RwHGl+eeMkGgtubvm9mcXyFVkOS1st63c/cAMY2ubP2zhK2jCKMBhjn653kbDZGq` |
| instrumentlanggraph.js                      | `sha384-OpWMJu6S3Z6nPui5e/5BYwaHQ4br1F7vt4UN5ud2XQuGCAXTrmZwejkVzOROey7h` |
| instrumentlanggraph.min.js                  | `sha384-sMZ/wWGaT4dM3bgJR1Mbq2P0VYnt5R6sPCIqIjwA1G6jRXKxjuC9MreTz+5FBL88` |
| instrumentopenaiclient.debug.min.js         | `sha384-BbrZe3fCxT8FiJMqzZRndlQfj+Af4U6vsXYQgvgcqYAWmVsmUCCPWGbow7UV4HWR` |
| instrumentopenaiclient.js                   | `sha384-wgnmBmqMqgngESSR9bpHLLTej9Zw8eqTyJEgAvtEe0tZ5GRT5tJahQkag0GltMmb` |
| instrumentopenaiclient.min.js               | `sha384-Dr9KRj67inUAV5DrBrTkrfDTO1B6e9KGOSHXz9DOxudFIBpOMLwp8x++SrsSFUNH` |
| modulemetadata.debug.min.js                 | `sha384-b0oiD8AixiPzwngS01z2NM9aOqIp4qfVBUJFq7XMuO64GXQUwnpRFO8F6mQrYfpO` |
| modulemetadata.js                           | `sha384-eMeEqZADUE9s3jt2HNt7DFnQfR1MrjZIevB/zYomTtk+YQNSz3Uv0/IJcgIvlQMp` |
| modulemetadata.min.js                       | `sha384-3AGc2jzWNl6jhxtboWaInRR0SB6Dx14PscOEuX/RKX6X8GFn9rLll50PGPmu979r` |
| multiplexedtransport.debug.min.js           | `sha384-O5DSC5vCL2VtL9yTyDGOw6ieI1znScdDAtaofv5HGoizAZ0N9An9QmQ/Z90C2pIe` |
| multiplexedtransport.js                     | `sha384-+hRFEX8a8+eDLkSbHr4TVDXcoGtQi87rUpdOlnExhIfx5gW+SggAEFWvjJysBmuU` |
| multiplexedtransport.min.js                 | `sha384-BfZmyTN0Fq9vZIcMct3lG9aWsdL/9S3I5y5KbA8gsYCQNQldIkhPV4ywLQtqjCJA` |
| replay-canvas.debug.min.js                  | `sha384-Wt6mgRk73XOxr7WbtqgD5ob/++4PXqjTqBqYzGOaQjKCD2yeQ8KNDjULzDaXNF1w` |
| replay-canvas.js                            | `sha384-K7uv9k3k16Tlm60+44KInbDRtlgVuUhpvHYSX9UdJ0GrrC0uHF6SnkE1b5pfJY9H` |
| replay-canvas.min.js                        | `sha384-+5Y9XswSge0qxW0BG3zK6Z2aVa4hcG6c49+oi44+bA5GSqytjFi/DEpJtuUckeZv` |
| replay.debug.min.js                         | `sha384-ktm8xa44lOgG8/yLkWAIacUJhycm8xnjHGzUNK7MeUl9m8ivh5hVb8D7cR96Eanj` |
| replay.js                                   | `sha384-0nvo4rKh97ph6YsyW5kD5DY7ktiJ+4SO+MfX9LTB1DTQ5sv+1+IqrPDvNm8eoUEu` |
| replay.min.js                               | `sha384-vrDxq7gGRy4bmdIvz5iAiUXw5sEmPd0iWkwVjp4i1c2NA1QXrfCAYiFM+2TBy327` |
| reportingobserver.debug.min.js              | `sha384-aOAN6ADDxE7PzD7ZvG3Vk5aGMqvTW52w4OCQqzxqr0HbG+5wMYt3BYMAQFRGeQAu` |
| reportingobserver.js                        | `sha384-8EZKe3P5E99b8cDgeSj0/tfHElChMPxTvfvqBgkd0bOi+qLzclKRxnkWLw0VyTgQ` |
| reportingobserver.min.js                    | `sha384-yI3qhZxoOxPHjhN4GlQ4ZlBAPLyF6DzPYBEcUdqIZHTf5WYQE+LLvJAignHcMqdO` |
| rewriteframes.debug.min.js                  | `sha384-twXmvWLo9BMprOpvpBBnW7UZWE+g/zEm9uWMj+XETaazet9EOI4lZQ4L9BxnPcS0` |
| rewriteframes.js                            | `sha384-ooBSFgxuASSWP/Pm/EFP46OJ0s4SjpFixy/l1DbwXDENtmTZvejoO2zG+E4I8jbS` |
| rewriteframes.min.js                        | `sha384-AbsWbR1zn+KaMyzE/U4xXLE/lGdCBspd4kDmpgULSuevh5V0yTS0+Zylw1kVMpkH` |
| spotlight.debug.min.js                      | `sha384-8WHgau72RJ9TIkPWkus9v7igu7b6fjO5ClatJ0NuLK/A5y0lhJtCqysa/n4rPImJ` |
| spotlight.js                                | `sha384-OhGZ+RSA8WEbPEp9j1qT6vJannXTfcqzw/rRa59zwL59C96uBzn1zDn8mH0uB5er` |
| spotlight.min.js                            | `sha384-1UFTc1PreTG+1tuwvsor/DFkafq4hoQAi1IPJcV6s4uHWpvBT7dHNFbvctTZFBSs` |

To find the integrity hashes for older SDK versions, you can view our SDK release registry for the Browser SDK [here](https://github.com/getsentry/sentry-release-registry/tree/master/packages/npm/@sentry/browser).

## [Additional Configuration](https://docs.sentry.io/platforms/javascript/guides/solid/install/loader.md#additional-configuration)

### [Using defer](https://docs.sentry.io/platforms/javascript/guides/solid/install/loader.md#using-defer)

If you use the [`defer` script attribute](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#attr-defer), we strongly recommend that you place the script tag for the browser SDK first and mark all of your other scripts with `defer` (but not `async`). This will guarantee that that the Sentry SDK is executed before any of the others.

Without doing this you will find that it's possible for errors to occur before Sentry is loaded, which means you'll be flying blind to those issues.

### [Content Security Policy](https://docs.sentry.io/platforms/javascript/guides/solid/install/loader.md#content-security-policy)

If you have a Content Security Policy (CSP) set up on your site, you will need to add the `script-src` of wherever you're loading the SDK from, and the origin of your DSN. For example:

* `script-src: https://browser.sentry-cdn.com https://js.sentry-cdn.com`
* `connect-src: *.sentry.io`
