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 presenta 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 regolano il proprio comportamento di archiviazione in base a uno stato del consenso granted o denied. Possono avere controlli del consenso integrati per uno dei seguenti tipi di consenso:

Creare un nuovo modello di consenso

La modalità di consenso tiene traccia delle scelte di consenso dei visitatori e i controlli del consenso dei tag assicurano 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 sua scelta di 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 del 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 di 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 di consenso o decida di modificare il 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, modifica il nome in region e seleziona la casella Richiedi che i valori delle colonne 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 i valori predefiniti del consenso per regioni diverse.
7. Fai clic su Aggiungi colonna, scegli Input di testo, modifica il nome in granted.
8. Espandi la colonna e modifica il nome visualizzato in Granted Consent Types (comma separated).
9. Fai clic su Aggiungi colonna, scegli Input di testo, 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 l'oscuramento dei dati pubblicitari:

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 in 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 in 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 dei modelli.
2. Nell'esempio di codice riportato di seguito, modifica i campi segnaposto.
3. Copia il codice e sostituisci il codice boilerplate nell'editor dei 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();

Poi, 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 Accede allo stato del consenso.
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. In Specifico, inserisci i nomi di ciascuno dei 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à

Per informazioni sulla creazione di test per il tuo modello, consulta Test.

3. Integra il modello con la soluzione di 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);
  });
};

Aggiorna lo stato del consenso

Una volta che il visitatore di un sito web ha indicato le proprie scelte di consenso, in genere tramite l'interazione con un banner di 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 caso, l'esempio utilizza 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 della regione

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

Ad esempio, il seguente comando imposta lo stato predefinito di analytics_storage su denied per i visitatori provenienti dalla Spagna e dall'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'
});

Il valore più specifico ha la precedenza

Se nella stessa pagina sono presenti due comandi di consenso predefiniti 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 avrà 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 di GTM.

Trasferire le informazioni sui clic sugli annunci, sull'ID cliente e sull'ID sessione negli URL

Quando un visitatore arriva sul sito web di un inserzionista dopo aver fatto clic su un annuncio, le informazioni sull'annuncio potrebbero essere aggiunte agli URL delle pagine 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 facoltativamente trasferire le informazioni sui clic sugli annunci tramite i parametri URL tra le pagine utilizzando una funzionalità chiamata trasferimento dei parametri URL.

Allo stesso modo, se analytics_storage è impostato su denied, il trasferimento dei parametri URL può essere utilizzato per inviare analisi basate su eventi e sessioni (incluse le conversioni) senza cookie tra le pagine.

Per utilizzare il trasferimento dei parametri URL, devono essere soddisfatte le seguenti condizioni:

• Nella pagina sono presenti tag Google sensibili al consenso.
• Il sito ha attivato l'utilizzo della funzionalità di trasferimento dei parametri URL.
• La modalità di consenso è implementata nella pagina.
• Il link in uscita fa riferimento allo stesso dominio della pagina corrente.
• Nell'URL è presente un gclid/dclid (solo tag Google Ads e Floodlight)

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

gtagSet('url_passthrough', true);

Oscurare i dati pubblicitari

Quando ad_storage è impostato su denied, 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 sui clic sugli annunci nei parametri URL.

Per oscurare ulteriormente i dati pubblicitari quando ad_storage è impostato su denied, imposta ads_data_redaction su true.

Quando ads_data_redaction è true e ad_storage è impostato su denied, 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 modello.

Hai bisogno di un ID sviluppatore solo se la tua implementazione verrà utilizzata su più siti web da aziende 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 agli utenti

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

• Come impostare i valori predefiniti del consenso nella tabella Impostazioni.
• Come impostare i valori predefiniti del consenso per regioni diverse aggiungendo altre righe alla 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.