> ## Documentation Index
> Fetch the complete documentation index at: https://help.scribe-mail.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Konverteringssporing

> Spor registreringer, demoer og kjøp på nettstedet med Scribe JavaScript SDK, og tilskriv hver konvertering til e-postsignaturen som utløste den.

Konverteringssporing lukker sirkelen for e-postsignaturene dine. Signaturanalyse viser deg allerede visninger og klikk. Med Scribe JavaScript SDK kan du også registrere hva som skjer videre på ditt eget nettsted – registreringer, bookede demoer og kjøp – og knytte hver av dem tilbake til signaturen, teammedlemmet og lenken som utløste dem. Dette er bunnen av trakten: visninger, deretter klikk, deretter konverteringer.

I Scribe kalles disse konverteringene **hendelser**. Du registrerer dem med noen få linjer JavaScript, og Scribe tilskriver dem automatisk ved hjelp av den samme klikksporingen som driver resten av analysene dine.

<Note>
  Konverteringssporing er tilgjengelig på betalte abonnementer. Hvis arbeidsområdets abonnement ikke inkluderer det, registrerer sporingskodesnutten ingenting.
</Note>

## Slik fungerer det

1. En mottaker klikker på en lenke i en av e-postsignaturene dine.
2. Scribe omdirigerer dem til nettstedet ditt og legger til en `scribe_click_id`-parameter i mål-URL-en.
3. Scribe SDK på landingssiden din leser denne `scribe_click_id`, lagrer den førsteparts og knytter den til hver hendelse du registrerer.
4. Når den besøkende konverterer, kaller du `scribe.track('signup')`. Scribe kobler hendelsen tilbake til det opprinnelige klikket.

Resultatet: du kan se hvilke signaturer, teammedlemmer og klikkede elementer som gir reelle konverteringer og inntekter, ikke bare klikk. Attribusjonen fungerer på avsender-, signatur- og elementnivå, og Scribe matcher en konvertering med et klikk i inntil 30 dager etter klikket.

Hvis en hendelse kommer inn uten en kjent `scribe_click_id` (direkte trafikk, en utløpt lenke eller en fjernet parameter), blir den likevel registrert. Den blir bare ikke tilskrevet et klikk.

## Før du starter

Du trenger tre ting:

* **Et betalt abonnement** som inkluderer konverteringssporing.
* **Sporing aktivert** for arbeidsområdet ditt. Dette er den samme innstillingen som driver signaturvisning og klikkanalyse. Slå den på først når du har det samtykket du trenger (se [Personvern og samtykke](#privacy-and-consent)).
* **Din Event Tracking ID.** Dette er en offentlig, ikke-hemmelig identifikator for arbeidsområdet ditt. Det er trygt å bygge den inn i HTML-en på nettstedet ditt.

<Steps>
  <Step title="Kopier din Event Tracking ID">
    I Scribe åpner du **Settings**, går til fanen **Workspace** og kopierer verdien under **Event Tracking ID**. Mens du er der, sørg for at **Tracking** er aktivert.
  </Step>

  <Step title="Legg til SDK-en på nettstedet ditt">
    Bruk skriptutdraget for et vanlig nettsted, eller npm-pakken for en app eller enkeltside-app. Begge eksponerer det samme `scribe.track(...)`-API-et.

    **Alternativ A. Skriptutdrag.** Legg dette til på hver side du vil spore, rett før den avsluttende `</head>`-taggen. Utdraget initialiseres automatisk fra `data-workspace`, så det er ingen `init()`-kall du trenger å gjøre.

    ```html theme={null}
    <!-- Scribe conversion tracking -->
    <script src="https://cdn-1.scribe-mail.com/v1/tracking.js"
            data-workspace="YOUR_EVENT_TRACKING_ID" async></script>
    ```

    **Alternativ B. npm eller yarn.** Installer pakken, og initialiser den deretter én gang ved appoppstart.

    ```bash theme={null}
    npm install @scribemail/js
    # or: yarn add @scribemail/js
    ```

    ```js theme={null}
    import scribe from '@scribemail/js';

    scribe.init({ id: 'YOUR_EVENT_TRACKING_ID' }); // once, at app startup
    ```

    Å importere modulen har ingen bivirkninger (den er trygg for server-side rendering). Ingenting sendes før du kaller `init()`.
  </Step>

  <Step title="Registrer din første konvertering">
    Kall `scribe.track` der en konvertering skjer, for eksempel i behandleren for vellykket registrering.

    ```js theme={null}
    scribe.track('signup', { value: 99.0, currency: 'USD', plan: 'pro' });
    ```

    SDK-en fanger opp Scribe-klikkattribusjonen fra landings-URL-en for deg, samler hendelsene dine i batcher og sender dem pålitelig, også når den besøkende navigerer bort.
  </Step>

  <Step title="Sjekk at det fungerer">
    Utløs hendelsen på nettstedet ditt, og åpne deretter **Analytics** i Scribe. Konverteringene dine vises ved siden av visninger og klikk, fordelt på signatur, teammedlem, kampanje og land.
  </Step>
</Steps>

## SDK-referanse

### `scribe.track(name, metadata)`

Registrerer en hendelse. `name` er påkrevd, for eksempel `signup`, `demo_booked` eller `purchase`.

```js theme={null}
scribe.track('purchase', {
  value: 149.0,           // optional, monetary value of the conversion
  currency: 'EUR',        // optional, ISO currency code
  event_id: 'order_8821', // optional, your own id, used for idempotency
  plan: 'team',           // any other key becomes an event "property"
  seats: 5
});
```

* `value`, `currency` og `event_id` er gjenkjente felter på øverste nivå.
* **Alle andre nøkler** blir en del av hendelsens `properties`. Hold egenskaper til flate skalarverdier (strenger, tall, boolske verdier). Ikke legg personopplysninger som e-post eller telefonnumre i egenskaper: Scribe fjerner automatisk nøkler som ser ut som personopplysninger.
* Angi din egen `event_id` for å gjøre det trygt å prøve en sending på nytt. Den samme `event_id` mottatt to ganger innen 24 timer registreres bare én gang.

### `scribe.identify(userId, traits)`

Knytter den besøkende til en av dine egne brukere, slik at du kan se hvilke signaturer som skaffer hvilke kunder. Nyttig for B2B og kontobasert arbeid.

```js theme={null}
scribe.identify('user_42', { email: 'ada@example.com', name: 'Ada', plan: 'pro' });
```

Etter et `identify`-kall knyttes påfølgende `track`-kall til den brukeren. Kall `scribe.reset()` ved utlogging for å tømme identiteten.

### `scribe.flush()`

Hendelser samles i batcher og sendes automatisk, og alltid når siden skjules. Kall `flush()` kun hvis du må tvinge den gjeldende batchen ut umiddelbart.

### Snippet-attributter

Når du bruker skript-snippet, konfigurerer du den med `data-*`-attributter:

| Attributt            | Påkrevd | Beskrivelse                                                                           |
| -------------------- | ------- | ------------------------------------------------------------------------------------- |
| `data-workspace`     | Ja      | Din Event Tracking ID.                                                                |
| `data-consent`       | Nei     | Sett til `"denied"` for å deaktivere førsteparts lagring til den besøkende samtykker. |
| `data-cookie-domain` | Nei     | Angi ditt apex-domene for å dele identitet på tvers av underdomener.                  |

### Content Security Policy

Hvis nettstedet ditt bruker en Content Security Policy, må du tillate Scribe-vertene:

```
script-src  https://cdn-1.scribe-mail.com;
connect-src https://t.scribe-mail.com;
```

<Tip>
  Trenger du å registrere en autoritativ hendelse fra backend-en din, for eksempel en betaling som serveren din har bekreftet? Scribe godtar også hendelser via API-et med en `events:write` API-nøkkel, noe som holder omsetningsverdier pålitelige i stedet for klientoppgitte. Se [API-referansen](/api-reference/introduction) for detaljer.
</Tip>

## Bruksområder: gjør konverteringer til vekst

Konverteringssporing gjør e-postsignaturene dine til en målbar anskaffelseskanal. Slik setter team dataene i arbeid, inkludert å mate dem inn i betalt remarketing.

### Kjør remarketingkampanjer på Google Ads og Meta Ads

Utløs konverteringspikslene fra annonseplattformene dine på samme sted som du kaller `scribe.track`, slik at én enkelt konvertering havner i Scribe, Google Ads og Meta samtidig. Scribe forteller deg at konverteringen kom fra en e-postsignatur; Google og Meta bruker det samme signalet til budgivning og målgrupper.

```js theme={null}
function onSignupComplete(plan, price) {
  // 1. Attribute the conversion to the email signature that drove it
  scribe.track('signup', { value: price, currency: 'USD', plan });

  // 2. Send the same conversion to your ad platforms for bidding and audiences
  // gtag('event', 'conversion', { send_to: 'AW-XXXXXXXXX/abc', value: price, currency: 'USD' });
  // fbq('track', 'CompleteRegistration', { value: price, currency: 'USD' });
}
```

### Bygg retargeting-målgrupper med høy intensjon

Folk som klikket på signaturen din og havnet på nettstedet ditt, men som ikke konverterte, er varme leads. Bruk Scribe til å bekrefte signaturdrevet trafikk, og retarget deretter disse besøkende med et tilpasset tilbud på Google og Meta. Fordi trafikken kommer fra dine egne e-poster, konverterer disse målgruppene som regel bedre enn kald prospektering.

### Så lookalike- og lignende målgrupper fra dem som konverterte

Din beste utgangsmålgruppe er personer som allerede har konvertert via en pålitelig kanal. Hent ut de besøkende som signaturer har skaffet (filtrer etter signatur, teammedlem eller kampanje), last dem opp som en Custom Audience i Meta eller en Customer Match-liste i Google Ads, og bygg Lookalike- eller Similar-målgrupper fra det høykvalitetsutgangspunktet.

### Ekskluder eksisterende kunder fra anskaffelseskostnader

Slutt å betale for å skaffe folk som allerede har registrert seg eller kjøpt. Eksporter konverteringene dine og legg dem til som en eksklusjons- eller undertrykkelsesliste på prospekteringskampanjene dine, slik at budsjettet går til helt nye prospekter.

### Optimaliser for inntekter, ikke bare klikk

Send en reell `value` og `currency` med hver konvertering. Med inntekter knyttet til kan du bytte Google og Meta til verdibasert budgivning, og i Scribe kan du rangere signaturer, teammedlemmer og kampanjer etter inntektene de genererer, ikke bare etter klikk.

### Bevis kanalen og omfordel budsjettet

Konverteringssporing lar deg sammenligne inntekter drevet av e-postsignaturer med de betalte kanalene dine på like vilkår. Når en signaturkampanje presterer bedre enn en betalt, har du tallene som trengs for å flytte budsjettet over til det som fungerer.

## Be en AI-agent sette det opp

Du trenger ikke koble dette opp for hånd. Hvis du bruker en AI-kodeassistent (som Claude Code, Cursor eller en lignende agent i editoren din), kan du lime inn en ledetekst som denne, med din egen Event Tracking ID og konverteringene du bryr deg om:

```text theme={null}
Install the Scribe conversion tracking SDK on my website.

- If this is an app or single-page app, add the @scribemail/js package and call
  scribe.init({ id: 'YOUR_EVENT_TRACKING_ID' }) once at startup. If it is a plain
  HTML site, add the https://cdn-1.scribe-mail.com/v1/tracking.js script with
  data-workspace="YOUR_EVENT_TRACKING_ID" before </head> instead.
- Call scribe.track('signup', { value, currency }) from my signup success handler
  and scribe.track('purchase', { value, currency }) from my checkout confirmation.
- If I have logged-in users, call scribe.identify(userId, { email, plan }) after login.
- Add https://cdn-1.scribe-mail.com and https://t.scribe-mail.com to my Content
  Security Policy if I have one.
```

Når konverteringene strømmer inn, kan en agent koblet til [Scribe MCP-serveren](/no/ai-agents/connect) lese og forklare resultatene for deg. Spør den om ting som «hvilke signaturer og teammedlemmer drev flest konverteringer og mest inntekter denne måneden?» eller «list opp besøkende signaturene mine skaffet denne uken.» Se [Scribe for AI-agenter](/no/ai-agents) og [Scribe-analyseferdigheten](/no/ai-agents/skills) for å se hva assistenten din kan hente.

## Personvern og samtykke

Konverteringssporing er bygget for å respektere både de besøkende og forpliktelsene dine:

* **IP-adresser anonymiseres.** Scribe hasher IP-adressen før den lagres. Rå IP-adresser lagres aldri.
* **Ingen personopplysninger i egenskaper.** Nøkler som ser ut som personopplysninger (e-post, telefon, passord, tokens, kortnumre og lignende) fjernes automatisk fra hendelsesegenskaper. Bruk `identify` når du bevisst ønsker å knytte til en bruker.
* **Samtykkestyrt lagring.** Sett `data-consent="denied"` (snippet) eller `consent: false` (npm `init`) for å hindre at SDK-en lagrer klikk-identifikatoren før den besøkende gir samtykke.
* **Innhent samtykke før du aktiverer sporing.** Innstillingen for sporing på arbeidsområdet innebærer det samme ansvaret som enhver analysepiksel. Sørg for at du har det samtykket din region krever før du slår den på.

## Relaterte artikler

* [Analytics-oversikt](/no/analytics-overview): visninger, klikk, rekkevidde og CTR på tvers av arbeidsområdet ditt.
* [Analytics-dashbord](/no/analytics-dashboard): les konverteringer ved siden av visninger og klikk i hver fane.
* [Signaturanalyse](/no/signature-analytics): ytelse for en enkelt signatur.
* [Markedsføringskampanjer](/no/marketing-overview): kjør og mål bannerkampanjer i signaturer.
* [Scribe for AI-agenter](/no/ai-agents): la en assistent sette opp sporing og rapportere om konverteringer.