Creare un modello per la modalità di consenso

Questo documento è rivolto agli sviluppatori che gestiscono una soluzione di gestione del consenso sui siti web che utilizzano Google Tag Manager (GTM).

Questa pagina introduce i tipi di consenso in Google Tag Manager e mostra come integrarli con la tua soluzione di gestione del consenso.

Stato del consenso e tipi di consenso

I tag Google e di terze parti modificano il loro comportamento di archiviazione in base a uno stato del consenso granted o denied. Possono avere controlli del consenso integrati per uno qualsiasi dei seguenti tipi di consenso:

Crea un nuovo modello di consenso

La modalità di consenso tiene traccia delle scelte di consenso dei visitatori e i controlli del consenso dei tag garantiscono che il comportamento dei tag venga modificato di conseguenza. Quando crei un nuovo modello di consenso, segui le best practice:

• Utilizza le API per la modalità di consenso di Tag Manager setDefaultConsentState e updateConsentState anziché gtag consent.

• Imposta gli stati del consenso predefiniti immediatamente dopo l'attivazione utilizzando l'attivatore Inizializzazione del consenso - Tutte le pagine.

• La CMP deve chiedere al visitatore il prima possibile di concedere o negare il consenso per tutti i tipi di consenso applicabili.

• Quando un visitatore indica la propria scelta relativa al consenso, la CMP deve trasmettere lo stato del consenso aggiornato.

1. Crea un nuovo modello

Questo approccio di implementazione utilizza un campo nel modello per contenere lo stato di consenso predefinito. Il codice di implementazione legge questo campo per impostare lo stato del consenso predefinito in fase di runtime. Per il comando di aggiornamento, il codice tenta di leggere un cookie impostato dalla soluzione per il consenso per memorizzare le scelte di consenso dei visitatori. Configurerai anche un callback per updateConsentState per gestire il caso in cui un visitatore non abbia ancora effettuato le selezioni del consenso o decida di modificare il proprio consenso.

Per creare un modello di consenso:

1. Accedi al tuo account Google Tag Manager.
2. Nel menu di navigazione a sinistra, seleziona Modelli.
3. Nel riquadro Modelli di tag, fai clic su Nuovo.

Per impostare gli stati del consenso predefiniti:

1. Seleziona la scheda Campi, fai clic su Aggiungi campo > Tabella dei parametri.
2. Modifica il nome in defaultSettings.
3. Espandi il campo.
4. Aggiorna il Nome visualizzato in Default settings.
5. Fai clic su Aggiungi colonna, scegli Input di testo, cambia il nome in region e seleziona la casella Richiedi che i valori della colonna siano univoci.
6. Espandi la colonna e modifica il nome visualizzato in Region (leave blank to have consent apply to all regions). L'istruzione tra parentesi è la documentazione per gli utenti del modello. Scopri di più su come configurare le impostazioni predefinite del consenso per regioni diverse.
7. Fai clic su Aggiungi colonna, scegli Input di testo e modifica il nome in granted.
8. Espandi la colonna e cambia il nome visualizzato in Granted Consent Types (comma separated).
9. Fai clic su Aggiungi colonna, scegli Input di testo e modifica il nome in denied.
10. Espandi la colonna e modifica il nome visualizzato in Denied Consent Types (comma separated).

(Facoltativo) Per aggiungere il supporto per la redazione dei dati degli annunci:

1. Fai clic su Aggiungi campo, scegli Casella di controllo e modifica il nome del campo in ads_data_redaction.
2. Aggiorna il nome visualizzato a Redact Ads Data

Scopri di più sul comportamento dei cookie con l'oscuramento dei dati pubblicitari

(Facoltativo) Per aggiungere il supporto per il trasferimento dei parametri URL:

1. Fai clic su Aggiungi campo, scegli Casella di controllo e modifica il nome del campo in url_passthrough.
2. Aggiorna il nome visualizzato a Pass through URL parameters

Scopri di più sul trasferimento dei parametri URL

Per aggiungere il codice di implementazione:

1. Apri la scheda Codice nell'editor di modelli.
2. Nell'esempio di codice riportato di seguito, modifica i campi segnaposto.
3. Copia il codice e sostituiscilo al codice standard nell'editor di modelli.
4. Salva il modello.

// The first two lines are optional, use if you want to enable logging
const log = require('logToConsole');
log('data =', data);
const setDefaultConsentState = require('setDefaultConsentState');
const updateConsentState = require('updateConsentState');
const getCookieValues = require('getCookieValues');
const callInWindow = require('callInWindow');
const gtagSet = require('gtagSet');
const JSON = require('JSON');
const COOKIE_NAME = 'Your_cookie_name';
/*
 *   Splits the input string using comma as a delimiter, returning an array of
 *   strings
 */
const splitInput = (input) => {
  if (!input) return [];
  return input.split(',')
      .map(entry => entry.trim())
      .filter(entry => entry.length !== 0);
};
/*
 *   Processes a row of input from the default settings table, returning an object
 *   which can be passed as an argument to setDefaultConsentState
 */
const parseCommandData = (settings) => {
  const regions = splitInput(settings['region']);
  const granted = splitInput(settings['granted']);
  const denied = splitInput(settings['denied']);
  const commandData = {};
  if (regions.length > 0) {
    commandData.region = regions;
  }
  granted.forEach(entry => {
    commandData[entry] = 'granted';
  });
  denied.forEach(entry => {
    commandData[entry] = 'denied';
  });
  return commandData;
};
/*
 *   Called when consent changes. Assumes that consent object contains keys which
 *   directly correspond to Google consent types.
 */
const onUserConsent = (consent) => {
  const consentModeStates = {
    ad_storage: consent['adConsentGranted'] ? 'granted' : 'denied',
    ad_user_data: consent['adUserDataConsentGranted'] ? 'granted' : 'denied',
    ad_personalization: consent['adPersonalizationConsentGranted'] ? 'granted' : 'denied',
    analytics_storage: consent['analyticsConsentGranted'] ? 'granted' : 'denied',
    functionality_storage: consent['functionalityConsentGranted'] ? 'granted' : 'denied',
    personalization_storage: consent['personalizationConsentGranted'] ? 'granted' : 'denied',
    security_storage: consent['securityConsentGranted'] ? 'granted' : 'denied',
  };
  updateConsentState(consentModeStates);
};
/*
 *   Executes the default command, sets the developer ID, and sets up the consent
 *   update callback
 */
const main = (data) => {
  /*
   * Optional settings using gtagSet
   */
  gtagSet('ads_data_redaction', data.ads_data_redaction);
  gtagSet('url_passthrough', data.url_passthrough);
  gtagSet('developer_id.your_developer_id', true);
  // Set default consent state(s). Add optional chaining to safely handle cases
  // where defaultSettings might be null or undefined.
  data.defaultSettings?.forEach(settings => {
    const defaultData = parseCommandData(settings);
    // wait_for_update (ms) allows for time to receive visitor choices from the CMP
    defaultData.wait_for_update = 500;
    setDefaultConsentState(defaultData);
  });

  // Check if cookie is set and has values that correspond to Google consent
  // types. If it does, run onUserConsent().
  const cookieValues = getCookieValues(COOKIE_NAME);
  if (cookieValues && cookieValues.length > 0) {
    try {
      const settings = JSON.parse(cookieValues[0]);
      if (settings) {
        onUserConsent(settings);
      }
    } catch (e) {
      // Log an error if the cookie value is not valid JSON.
    }
  }
  /**
   *   Add event listener to trigger update when consent changes
   *
   *   References an external method on the window object which accepts a
   *   function as an argument. If you do not have such a method, you will need
   *   to create one before continuing. This method should add the function
   *   that is passed as an argument as a callback for an event emitted when
   *   the user updates their consent. The callback should be called with an
   *   object containing fields that correspond to the five built-in Google
   *   consent types.
   */
  callInWindow('addConsentListenerExample', onUserConsent);
};
main(data);
data.gtmOnSuccess();

Successivamente, configura le autorizzazioni per accedere allo stato del consenso e ai cookie.

Per aggiungere le autorizzazioni per la gestione degli stati del consenso:

1. Seleziona la scheda Autorizzazioni e fai clic su Stato del consenso per gli accessi.
2. Fai clic su Aggiungi tipo di consenso.
3. Fai clic sulla casella e seleziona ad_storage dal menu a discesa.
4. Seleziona Scrivi.
5. Fai clic su Aggiungi.
6. Ripeti i passaggi da 2 a 5 per ad_user_data, ad_personalization e analytics_storage. Se hai bisogno di altri tipi di consenso, aggiungili nello stesso modo.
7. Fai clic su Salva.

Per aggiungere le autorizzazioni per l'accesso ai cookie:

1. Seleziona la scheda Autorizzazioni e fai clic su Legge i valori dei cookie.
2. Nella sezione Specifico, inserisci i nomi di ciascun cookie che il codice deve leggere per determinare le scelte di consenso dell'utente, un nome per riga.
3. Fai clic su Salva.

2. Crea test delle unità

Consulta Test per informazioni sulla creazione di test per il tuo modello.

3. Integra il modello con la soluzione per il consenso

Il seguente codice mostra un esempio di come questo modello potrebbe essere integrato con il codice della tua soluzione di gestione del consenso aggiungendo un listener:

// Array of callbacks to be executed when consent changes
const consentListeners = [];

/**
 *   Called from GTM template to set callback to be executed when user consent is provided.
 *   @param {function} Callback to execute on user consent
 */
window.addConsentListenerExample = (callback) => {
  consentListeners.push(callback);
};

/**
 *   Called when user grants/denies consent.
 *   @param {Object} Object containing user consent settings.
 */
const onConsentChange = (consent) => {
  consentListeners.forEach((callback) => {
    callback(consent);
  });
};

Aggiornare lo stato del consenso

Una volta che il visitatore di un sito web ha indicato le proprie scelte relative al consenso, in genere interagendo con un banner del consenso, il codice del modello deve aggiornare gli stati del consenso di conseguenza con l'API updateConsentState.

L'esempio seguente mostra la chiamata updateConsentState per un visitatore che ha indicato di acconsentire a tutti i tipi di archiviazione. Anche in questo esempio vengono utilizzati valori hardcoded per granted, ma in pratica questi valori devono essere determinati in fase di runtime utilizzando il consenso del visitatore raccolto dalla CMP.

const updateConsentState = require('updateConsentState');

updateConsentState({
  'ad_storage': 'granted',
  'ad_user_data': 'granted',
  'ad_personalization': 'granted',
  'analytics_storage': 'granted',
  'functionality_storage': 'granted',
  'personalization_storage': 'granted',
  'security_storage': 'granted'
});

Informazioni sul comportamento specifico per regione

Per impostare stati di consenso predefiniti da applicare ai visitatori provenienti da determinate aree, specifica una regione (in base alla ISO 3166-2) nel modello. L'utilizzo dei valori delle regioni consente agli utenti dei modelli di rispettare le normative regionali senza perdere le informazioni dei visitatori al di fuori di queste regioni. Quando una regione non è specificata in un comando setDefaultConsentState, il valore si applica a tutte le altre regioni.

Ad esempio, il seguente codice imposta lo stato predefinito per analytics_storage su denied per i visitatori provenienti da Spagna e Alaska e imposta analytics_storage su granted per tutti gli altri:

const setDefaultConsentState = require('setDefaultConsentState');

setDefaultConsentState({
  'analytics_storage': 'denied',
  'region': ['ES', 'US-AK']
});
setDefaultConsentState({
  'analytics_storage': 'granted'
});

La più specifica ha la precedenza

Se nella stessa pagina sono presenti due comandi predefiniti per il consenso con valori per una regione e una sottoregione, avrà effetto quello con la regione più specifica. Ad esempio, se hai impostato ad_storage su 'granted' per la regione US e ad_storage su 'denied' per la regione US-CA, un visitatore della California vedrà applicata l'impostazione più specifica US-CA.

Metadati aggiuntivi

Puoi utilizzare l'API gtagSet per impostare i seguenti parametri facoltativi:

• url_passthrough
• ads_data_redaction
• developer_id

Queste API sono disponibili solo nell'ambiente sandbox dei modelli GTM.

Trasferire le informazioni su clic sull'annuncio, ID client e ID sessione negli URL

Quando un visitatore arriva al sito web di un inserzionista dopo aver fatto clic su un annuncio, le informazioni sull'annuncio potrebbero essere aggiunte agli URL pagina di destinazione come parametro di query. Per migliorare l'accuratezza delle conversioni, i tag Google di solito memorizzano queste informazioni nei cookie proprietari sul dominio dell'inserzionista.

Tuttavia, se ad_storage è denied, i tag Google non salvano queste informazioni localmente. Per migliorare la qualità della misurazione dei clic sugli annunci in questo caso, gli inserzionisti possono trasferire facoltativamente le informazioni sui clic sugli annunci tramite i parametri URL tra le pagine utilizzando una funzionalità chiamata trasferimento URL.

Analogamente, se analytics_storage è impostato su "negato", è possibile utilizzare il trasferimento dell'URL per inviare analisi basate su eventi e sessioni (incluse le conversioni) senza cookie tra le pagine.

Per utilizzare il trasferimento dell'URL, devono essere soddisfatte le seguenti condizioni:

• Nella pagina sono presenti tag Google sensibili al consenso.
• Il sito ha attivato la funzionalità Passthrough URL.
• La modalità di consenso è implementata sulla pagina.
• Il link in uscita fa riferimento allo stesso dominio del dominio della pagina corrente.
• Un gclid/dclid è presente nell'URL (solo tag Google Ads e Floodlight)

Il modello deve consentire all'utente di configurare l'attivazione o meno di questa impostazione. Il seguente codice modello viene utilizzato per impostare url_passthrough su true:

gtagSet('url_passthrough', true);

Oscurare i dati pubblicitari

Quando ad_storage viene negato, non vengono impostati nuovi cookie per scopi pubblicitari. Inoltre, i cookie di terze parti precedentemente impostati su google.com e doubleclick.net non verranno utilizzati. I dati inviati a Google includeranno comunque l'URL completo della pagina, incluse le informazioni relative ai clic sugli annunci nei parametri URL.

Per oscurare ulteriormente i dati degli annunci quando ad_storage viene negato, imposta ads_data_redaction su true.

Quando ads_data_redaction è true e ad_storage è negato, gli identificatori dei clic sugli annunci inviati nelle richieste di rete dai tag Google Ads e Floodlight verranno oscurati.

gtagSet('ads_data_redaction', true);

ID sviluppatore

Se sei un fornitore di CMP con un ID sviluppatore rilasciato da Google, utilizza il seguente metodo per impostarlo il prima possibile nel tuo modello.

Hai bisogno di un ID sviluppatore solo quando la tua implementazione verrà utilizzata su più siti web da società o entità non correlate. Se l'implementazione verrà utilizzata da un solo sito o entità, non richiedere un ID sviluppatore.

gtagSet('developer_id.<your_developer_id>', true);

Fornire documentazione per gli utenti

Gli utenti utilizzeranno il modello di consenso per configurare un tag che raccoglie il consenso degli utenti. Fornisci agli utenti una documentazione che spieghi le seguenti best practice:

• Come impostare i valori predefiniti per il consenso nella tabella Impostazioni.
• Come configurare i valori predefiniti del consenso per diverse regioni aggiungendo altre righe della tabella.
• Attiva il tag con l'attivatore Inizializzazione del consenso - Tutte le pagine.

Passaggi successivi

Se vuoi fornire il tuo modello a tutti gli utenti di Tag Manager, caricalo nella Galleria modelli della community.