# Adobe Analytics

The c15t adobeAnalytics helper loads your Adobe Data Collection Tags property only while visitors allow measurement in Inth. Every extension in the property runs under that one choice.

## Key facts

- **Tool:** Adobe Analytics
- **Category:** Analytics
- **Consent categories:** Measurement
- **Setup method:** c15t package
- **Package:** @c15t/integrations

## Links

- [Documentation](https://c15t.com/docs/integrations/adobe-analytics)

Keep your Adobe Data Collection Tags property off the page until visitors allow measurement. Then every extension in that property runs under the same choice.

Inth keeps the consent record of each choice, with the visitor’s country and the policy that applied.

[Start for free](/dashboard/sign-up)

## Before you start

You need an Inth project that connects to your app, c15t in that app and the full embed URL of your Tags property environment. You find it in the Adobe Data Collection embed code.

New to c15t? Complete the quickstart for your framework first. Keep its Inth endpoint, policy, styles and consent UI.

[Open the quickstart for your framework](https://c15t.com/docs/frameworks)

## How consent gets to Adobe

The c15t adobeAnalytics helper adds the property embed only while measurement has permission. It sends no consent signal to Adobe.

The property can load Adobe Analytics, Web SDK and other extensions through its rules. c15t sees only the embed script. So all of these extensions run under the one measurement permission.

If a rule loads a service for a different purpose, such as ads, set that rule in Adobe to obey your consent model too.

Adobe has no shared loader that takes only an account ID. That is why the helper needs the full embed URL.

## Installation

Adobe Analytics has one load mode in c15t. The helper waits for measurement permission.

### Wait for permission

Adobe gets no request until the visitor accepts measurement. On withdrawal, c15t removes the embed and reloads the page.

```ts
adobeAnalytics({ scriptUrl })
```

An opt-out policy or no policy gives optional categories permission before a choice. Then Adobe Analytics loads on the first page. This guide uses an opt-in policy.

## Setup steps

#### Install the integration package

Add the helpers next to c15t. An import alone does not start the Tags property.

```
pnpm add @c15t/integrations
```

#### Add your property embed URL

Paste the full https embed URL for the property environment. The helper trims the value.

```
import { adobeAnalytics } from '@c15t/integrations/adobe-analytics';

export const scripts = [
  adobeAnalytics({
    scriptUrl:
      'https://assets.adobedtm.com/YOUR_ORG/YOUR_PROPERTY/launch-production.min.js',
  }),
];
```

An empty, unparseable or non-https URL logs an error, and the property does not load. By default, if window.adobeDataLayer has no value, the helper sets it to an empty array.

### Register it with your existing setup

#### Next.js

Add scripts to c15t.config.ts, next to next.config.ts. Keep the rest of your config, such as mode, in the same call. App Router, Pages Router and static export read the same file.

```
import { defineConsentConfig } from 'c15t/next';
import { scripts } from './src/consent-scripts';

export default defineConsentConfig({ scripts });
```

#### TanStack Start

Pass scripts to the ConsentRoot in your root route. Import helpers in the route module, not in a server function: script configurations carry callbacks.

```
import { scripts } from '../consent-scripts';

<ConsentRoot state={consent} scripts={scripts}>
```

#### React

Add scripts to the options of your ConsentProvider, next to mode. Keep the banner, dialog and preferences link inside the provider.

```
import { scripts } from './consent-scripts';

<ConsentProvider options={{ mode, scripts }}>
```

#### Nuxt

Register scripts under the c15t key in app.config.ts. Keep them out of nuxt.config.ts, which reaches the browser as JSON and drops the helper callbacks.

```
import { scripts } from '../src/consent-scripts';

export default defineAppConfig({
  c15t: { scripts },
});
```

#### Vue

Pass scripts to the c15tVue plugin call you have now. The plugin starts one script loader when the app mounts.

```
import { c15tVue, manifest } from 'c15t/vue/vue-plugin';
import { scripts } from './consent-scripts';

app.use(c15tVue, {
  mode: manifest(),
  scripts,
});
```

#### Astro

Add scripts to the client entrypoint, which the integration finds on its own. Keep helpers out of astro.config.mjs: its options are serialized into the page.

```
import type { C15tClientOptionsExtension } from 'c15t/astro';
import { scripts } from './consent-scripts';

export default { scripts } satisfies C15tClientOptionsExtension;
```

#### Svelte

Pass scripts as a prop to the ConsentProvider you have now. The provider owns the loader and disposes it on unmount.

```
<script lang="ts">
  import { ConsentProvider, manifest } from 'c15t/svelte';
  import { scripts } from './consent-scripts';
</script>

<ConsentProvider mode={manifest()} {scripts}>
  <!-- Your app and consent UI -->
</ConsentProvider>
```

#### SvelteKit

Add scripts to the ConsentRoot in the root layout. Import helpers in the layout component, not in +layout.server.ts: a server load cannot send functions to the browser.

```
<script lang="ts">
  import { ConsentRoot } from 'c15t/svelte';
  import { scripts } from '../consent-scripts';

  let { children, data } = $props();
</script>

<ConsentRoot state={data.consent} {scripts}>
  {@render children()}
</ConsentRoot>
```

#### HTML: Paste the vendor’s snippet behind consent

The helpers need a bundler. On a page with the c15t script tag, paste the vendor’s own snippet instead and keep it inert until visitors allow its category. Helper options, such as loadMode, do not apply.

```
<script type="text/plain" data-c15t-category="measurement">
  // The vendor's snippet, unchanged
</script>
```

#### JavaScript

Pass scripts to init() from @c15t/browser, next to your mode. With createConsentRuntime, pass scripts to it instead.

```
import { init, manifest } from '@c15t/browser';
import { scripts } from './consent-scripts';

const consent = init({
  mode: manifest(),
  scripts,
});
```

Remove the original Adobe embed code, so the property loads only through c15t. If you already have a scripts array, add the helper to it.

## Verify your setup

Use a private window with an opt-in policy. Open DevTools Network and filter by adobedtm. Then test the three states.

- **Before a choice**: No request goes to your embed URL. Click Reject and reload. There is still no request.

- **After you allow measurement**: The request for your embed URL starts without a page reload. Requests from the extensions in the property follow. window.\_satellite exists after the Tags library runs.

- **After you withdraw measurement**: Save your choice. c15t reloads the page. The new page sends no request to your embed URL.

Make sure that the requests from each extension match the measurement purpose. The reload does not delete cookies that Adobe set before.

[Open the full Adobe Analytics guide](https://c15t.com/docs/integrations/adobe-analytics)

## Related guides

- [Ahrefs Analytics](/integrations/ahrefs-analytics)

- [Databuddy](/integrations/databuddy)

- [Fathom Analytics](/integrations/fathom-analytics)