Mise en correspondance des données fournies par l'utilisateur

La mise en correspondance des données fournies par l'utilisateur associe les données first party que vous avez collectées sur un utilisateur, telles que les informations issues de vos sites Web, applications ou magasins physiques, à l'activité de ce même utilisateur (lorsqu'il est connecté) dans toutes les données sur les annonces Google, y compris les données détenues et gérées par Google. Cela inclut les données achetées via les produits Google Marketing Platform (GMP), par exemple, les données YouTube achetées à l'aide de Display & Video 360. Les autres produits GMP qui ne sont pas détenus ni gérés par Google ne sont pas compatibles.

Pour être éligible à la MCDFU, l'événement d'annonce doit être associé à un utilisateur connecté dans les données sur les annonces Google.

Ce document décrit la fonctionnalité de mise en correspondance des données fournies par l'utilisateur et fournit des conseils sur la configuration et l'utilisation.

Présentation de Private Cloud Match

Pour obtenir des insights publicitaires précieux, vous devez souvent assembler des données provenant de plusieurs sources. Créer votre propre solution à ce problème de pipeline de données nécessite un investissement en temps et en ingénierie important. La mise en correspondance dans le cloud privé d'Ads Data Hub simplifie ce processus en fournissant un modèle de requête Ads Data Hub permettant de créer une table de mise en correspondance dans BigQuery, qui peut ensuite être utilisée dans vos requêtes Ads Data Hub pour mettre en correspondance vos données publicitaires avec vos données first party. En enrichissant vos requêtes avec des données first party, vous pouvez proposer des expériences client plus riches et mieux vous adapter aux changements dans l'ensemble du secteur concernant le suivi des annonces.

Étant donné que la mise en correspondance des données fournies par l'utilisateur n'est disponible que sur l'inventaire détenu et géré par Google pour les utilisateurs connectés, elle n'est pas affectée par l'abandon à venir des cookies tiers. Comme elles résistent mieux aux évolutions du secteur que les données tierces, elles peuvent fournir des insights plus riches, ce qui peut entraîner un meilleur engagement client.

Résumé du processus

  1. Configuration de l'ingestion et de la mise en correspondance des données
  2. Ingestion et mise en correspondance des données first party
    • Vous mettez en forme et importez vos données first party dans votre ensemble de données BigQuery.
    • Vous lancez une demande de mise en correspondance des données en créant une requête d'analyse de mise en correspondance Private Cloud et en définissant un calendrier.
    • Google joint les données de votre projet aux données appartenant à Google contenant l'ID utilisateur de Google et les données hachées fournies par l'utilisateur pour créer et mettre à jour des tables de correspondance.
    • Consultez Ingérer des données first party.
  3. Requêtes en cours dans Ads Data Hub, basées sur les données mises en correspondance

En savoir plus sur les exigences en matière de confidentialité

Collecter des données client

Lorsque vous utilisez la mise en correspondance des données fournies par l'utilisateur, vous devez importer des données first party. Il peut s'agir d'informations que vous avez collectées sur vos sites Web, applications ou magasins physiques, ou encore de toute information qu'un client vous a communiquée directement.

Vous devez respecter les points suivants :

  • Dans vos règles de confidentialité, vous devez indiquer que vous partagez les données client avec des tiers pour qu'ils réalisent des services à votre place. Vous devez également spécifier que vous demandez le consentement des utilisateurs concernés lorsque la législation l'impose.
  • Vous ne devez utiliser que l'interface ou l'API approuvée de Google pour importer des données client.
  • Respectez l'ensemble des lois et règlements applicables, y compris les consignes d'autorégulation ou normes sectorielles qui peuvent s'appliquer.

Confirmation de l'obtention du consentement pour les données first party

Pour vous assurer de pouvoir utiliser vos données first party dans Ads Data Hub, vous devez confirmer avoir obtenu le consentement approprié pour transmettre à Google les données des utilisateurs finaux dans l'EEE conformément aux Règles relatives au consentement de l'utilisateur dans l'UE et aux Règles Ads Data Hub. Cette exigence s'applique à chaque compte Ads Data Hub et vous devez réeffectuer cette confirmation chaque fois que vous importez de nouvelles données first party. Tout utilisateur peut effectuer cette confirmation au nom de l'intégralité du compte.

Notez que les règles de requête des services Google qui s'appliquent aux requêtes d'analyse s'appliquent aussi aux requêtes UPDM. Par exemple, vous ne pouvez pas exécuter de requêtes multiservices sur des utilisateurs dans l'EEE lorsque vous créez une table des correspondances.

Pour découvrir comment confirmer l'obtention du consentement dans Ads Data Hub, consultez Exigences de consentement pour l'Espace économique européen.

Taille des données

Pour protéger la confidentialité des utilisateurs finaux, la mise en correspondance des données fournies par l'utilisateur applique ces exigences concernant la taille de vos données:

  • Vous devez importer au moins 1 000 enregistrements dans votre liste d'utilisateurs.
  • Votre liste ne doit pas dépasser le nombre maximal d'enregistrements. Pour en savoir plus sur la limite de données maximale, contactez votre représentant Google.

Configurer l'ingestion de données

Avant de commencer, vérifiez les points suivants:

  • Vos données first party doivent se trouver dans BigQuery. Si vous disposez d'un périmètre VPC-SC, ces données first party doivent se trouver dans votre VPC-SC.
  • Votre compte de service Ads Data Hub doit disposer d'un accès en lecture aux données first party.
  • Vos données first party doivent être mises en forme et hachées correctement. Pour en savoir plus, consultez la section suivante.

En dehors de cela, Private Cloud Match ne nécessite aucune intégration supplémentaire. Si vous pouvez exécuter une requête d'analyse, vous pouvez exécuter une requête de correspondance dans le cloud privé.

Ingestion et mise en correspondance des données first party

Mettre en forme les données pour l'entrée

Pour être correctement mises en correspondance, vos données doivent respecter les exigences de mise en forme suivantes:

  • Lorsque cela est indiqué dans les descriptions des champs de saisie suivantes, vous devez effectuer l'importation à l'aide du hachage SHA256.
  • Les champs de saisie doivent être au format chaîne. Par exemple, si vous utilisez la fonction de hachage SHA256 de BigQuery avec la fonction d'encodage Base64 (TO_BASE64), utilisez la transformation suivante: TO_BASE64(SHA256(user_data)).
  • UPDM est compatible avec l'encodage Base64. Vous devez aligner l'encodage de vos données first party sur le décodage utilisé dans votre requête Ads Data Hub. Si vous modifiez l'encodage de vos données first party, vous devez mettre à jour votre requête Ads Data Hub pour la décoder à partir de la même base. Les exemples suivants utilisent l'encodage Base64.

User-ID

  • Texte brut
  • Hachage: aucun

E-mail

  • Supprimez les espaces blancs de début et de fin.
  • N'utilisez que des minuscules.
  • Incluez un nom de domaine pour chaque adresse e-mail (par exemple, gmail.com ou hotmail.co.jp).
  • Supprimez les accents (par exemple, remplacez è, é, ê ou ë par e).
  • Supprimez tous les points (.) qui précèdent le nom de domaine dans les adresses e-mail gmail.com et googlemail.com.
  • Hachage: SHA256 encodé en base64

Valide:TO_BASE64(SHA256("jeffersonloveshiking@gmail.com"))

Non valide: TO_BASE64(SHA256(" Jéfferson.Lôves.Hiking@gmail.com "))

Téléphone

  • Supprimer les espaces blancs
  • Format au format E.164 (exemple pour les États-Unis: +14155552671, exemple pour le Royaume-Uni: +442071838750)
  • Supprimez tous les caractères spéciaux, à l'exception du signe "+" avant le code pays.
  • Hachage: SHA256 encodé en base64

Valide: TO_BASE64(SHA256("+18005550101"))

Non valide: TO_BASE64(SHA256("(800) 555-0101"))

Prénom

  • Supprimer les espaces blancs
  • N'utilisez que des minuscules.
  • Supprimez tous les préfixes (par exemple, Mme, M., Mme Dr.
  • Ne supprimez pas les accents (par exemple, è, é, ê ou ë).
  • Hachage: SHA256 encodé en base64

Valide: TO_BASE64(SHA256("daní"))

Non valide: TO_BASE64(SHA256("Mrs. Daní"))

Nom

  • Supprimer les espaces blancs
  • N'utilisez que des minuscules.
  • Supprimez tous les suffixes (par exemple, "Jr.", Sr., 2e, 3e, II, III, PHD, MD
  • Ne supprimez pas les accents (par exemple, è, é, ê ou ë).
  • Hachage: SHA256 encodé en base64

Valide:TO_BASE64(SHA256("délacruz"))

Non valide: TO_BASE64(SHA256("dé la Cruz, Jr."))

Pays

  • Incluez le code pays même si toutes vos données client proviennent du même pays.
  • Ne hachez pas les données de pays.
  • Utiliser les codes pays ISO 3166-1 alpha-2
  • Hachage: aucun

Valide:US

Non valide:United States of America ou USA

Code postal

  • Ne hachez pas les données de code postal.
  • Les codes postaux internationaux et ceux des États-Unis sont acceptés.
  • Pour les États-Unis :
    • Les codes à cinq chiffres sont acceptés (par exemple, 94043).
    • Les codes à cinq chiffres suivis d'une extension de quatre chiffres sont également autorisés (par exemple, 94043-1351 ou 940431351).
  • Pour tous les autres pays :
    • Aucune mise en forme n'est requise (pas besoin de mettre en minuscules, ni de supprimer les espaces et les caractères spéciaux)
    • N'indiquez pas l'extension de code postal.
  • Hachage: aucun

Validation des hachages et codage des données

Vous pouvez utiliser les scripts de validation de hachage suivants pour vous assurer que vos données sont correctement formatées.

JavaScript

  /**
   * @fileoverview Provides the hashing algorithm, as well as some valid hashes of
   * sample data for testing.
  */

  async function hash(token) {
    // Removes leading or trailing spaces and converts all characters to lowercase.
    const formattedToken = token.trim().toLowerCase();
    // Hashes the formatted string using the SHA-256 hashing algorithm.
    const hashBuffer = await crypto.subtle.digest(
        'SHA-256', (new TextEncoder()).encode(formattedToken));
    // Converts the hash buffer to a base64-encoded string and returns it.
    const base64Str = btoa(String.fromCharCode(...new Uint8Array(hashBuffer)));
    return base64Str;
  }

  function main() {
    // Expected hash for test@gmail.com:
    // h5JGBrQTGorO7q6IaFMfu5cSqqB6XTp1aybOD11spnQ=
    hash('test@gmail.com').then(result => console.log(result));

    // Expected hash for +18005551212:
    // YdkRG+0+bZz8G8O1yzWkAmh8TxVGvuBhor1ET73WTEQ=
    hash('+18005551212').then(result => console.log(result));

    // Expected hash for John: ltljLzY1ZMwwMlIUCc8iqFLyAy7sCZ7VlnwNAAzsYHo=
    hash('John').then(result => console.log(result));

    // Expected hash for Doe: eZ75KhGvkY4/t0HfQpNPO1aO0tk6wd908bjUGieTKm8=
    hash('Doe').then(result => console.log(result));
  }

  main()

Python

  """Provides the hashing algorithm, as well as some valid hashes of sample data for testing.

  Supports: Python 2, Python 3

  Sample hashes:

    - Email 'test@gmail.com': h5JGBrQTGorO7q6IaFMfu5cSqqB6XTp1aybOD11spnQ=
    - Phone '+18005551212':   YdkRG+0+bZz8G8O1yzWkAmh8TxVGvuBhor1ET73WTEQ=
    - First name 'John':      ltljLzY1ZMwwMlIUCc8iqFLyAy7sCZ7VlnwNAAzsYHo=
    - Last name 'Doe':        eZ75KhGvkY4/t0HfQpNPO1aO0tk6wd908bjUGieTKm8=
  """

  import base64
  import hashlib

  def hash(token):
  # Generates a base64-encoded SHA-256 hash of a normalized input string.
    return base64.b64encode(
        hashlib.sha256(
            token.strip().lower().encode('utf-8')).digest()).decode('utf-8')

  def print_hash(token, expected=None):
  # Computes and displays the hash of a token, with optional validation.
    hashed = hash(token)

    if expected is not None and hashed != expected:
      print(
          'ERROR: Incorrect hash for token "{}". Expected "{}", got "{}"'.format(
              token, expected, hashed))
      return

    print('Hash: "{}"\t(Token: {})'.format(hashed, token))

  def main():
  # Tests the hash function with sample tokens and expected results.
    print_hash(
        'test@gmail.com', expected='h5JGBrQTGorO7q6IaFMfu5cSqqB6XTp1aybOD11spnQ=')
    print_hash(
        '+18005551212', expected='YdkRG+0+bZz8G8O1yzWkAmh8TxVGvuBhor1ET73WTEQ=')
    print_hash('John', expected='ltljLzY1ZMwwMlIUCc8iqFLyAy7sCZ7VlnwNAAzsYHo=')
    print_hash('Doe', expected='eZ75KhGvkY4/t0HfQpNPO1aO0tk6wd908bjUGieTKm8=')

  if __name__ == '__main__':
    main()

Go

  /*
  Provides the hashing algorithm, as well as some valid hashes of sample data for testing.

  Sample hashes:

    - Email 'test@gmail.com': h5JGBrQTGorO7q6IaFMfu5cSqqB6XTp1aybOD11spnQ=
    - Phone '+18005551212':   YdkRG+0+bZz8G8O1yzWkAmh8TxVGvuBhor1ET73WTEQ=
    - First name 'John':      ltljLzY1ZMwwMlIUCc8iqFLyAy7sCZ7VlnwNAAzsYHo=
    - Last name 'Doe':        eZ75KhGvkY4/t0HfQpNPO1aO0tk6wd908bjUGieTKm8=
  */
  package main

  import (
    "crypto/sha256"
    "encoding/base64"
    "fmt"
    "strings"
  )

  // Hash hashes an email, phone, first name, or last name into the correct format.
  func Hash(token string) string {
    formatted := strings.TrimSpace(strings.ToLower(token))
    hashed := sha256.Sum256([]byte(formatted))
    encoded := base64.StdEncoding.EncodeToString(hashed[:])
    return encoded
  }

  // PrintHash prints the hash for a token.
  func PrintHash(token string) {
    fmt.Printf("Hash: \"%s\"\t(Token: %s)\n", Hash(token), token)

  }

  func main() {
    PrintHash("test@gmail.com")
    PrintHash("+18005551212")
    PrintHash("John")
    PrintHash("Doe")
  }

Java

  package updm.hashing;

  import static java.nio.charset.StandardCharsets.UTF_8;

  import java.security.MessageDigest;
  import java.security.NoSuchAlgorithmException;
  import java.util.Base64;

  /**
  * Example of the hashing algorithm.
  *
  * <p>Sample hashes:
  *
  * <ul>
  *   <li>Email 'test@gmail.com': h5JGBrQTGorO7q6IaFMfu5cSqqB6XTp1aybOD11spnQ=
  *   <li>Phone '+18005551212': YdkRG+0+bZz8G8O1yzWkAmh8TxVGvuBhor1ET73WTEQ=
  *   <li>First name 'John': ltljLzY1ZMwwMlIUCc8iqFLyAy7sCZ7VlnwNAAzsYHo=
  *   <li>Last name 'Doe': eZ75KhGvkY4/t0HfQpNPO1aO0tk6wd908bjUGieTKm8=
  * </ul>
  */
  public final class HashExample {

  private HashExample() {}

  public static String hash(String token) {
    // Normalizes and hashes the input token using SHA-256 and Base64 encoding.
    String formattedToken = token.toLowerCase().strip();

    byte[] hash;
    try {
      hash = MessageDigest.getInstance("SHA-256").digest(formattedToken.getBytes(UTF_8));
    } catch (NoSuchAlgorithmException e) {
      throw new IllegalStateException("SHA-256 not supported", e);
    }

    return Base64.getEncoder().encodeToString(hash);
  }

  public static void printHash(String token) {
    // Calculates and prints the hash for the given token.
    System.out.printf("Hash: \"%s\"\t(Token: %s)\n", hash(token), token);
  }

  public static void main(String[] args) {
    // Executes hash calculations and prints results for sample tokens.
    printHash("test@gmail.com");
    printHash("+18005551212");
    printHash("John");
    printHash("Doe");
  }
  }

SQL

  /*
  Provides the hashing algorithm, as well as some valid hashes of sample data for testing.

  The following code uses Google Standard SQL and can be run on BigQuery to generate match tables from unhashed data.

  Sample hashes:

    - Email 'test@gmail.com': h5JGBrQTGorO7q6IaFMfu5cSqqB6XTp1aybOD11spnQ=
    - Phone '+18005551212':   YdkRG+0+bZz8G8O1yzWkAmh8TxVGvuBhor1ET73WTEQ=
    - First name 'John':      ltljLzY1ZMwwMlIUCc8iqFLyAy7sCZ7VlnwNAAzsYHo=
    - Last name 'Doe':        eZ75KhGvkY4/t0HfQpNPO1aO0tk6wd908bjUGieTKm8=

  The unhashed input table schema is assumed to be:

  - Column name: UserID, Type: String
  - Column name: Email, Type: String
  - Column name: Phone, Type: String
  - Column name: FirstName, Type: String
  - Column name: LastName, Type: String
  - Column name: PostalCode, Type: String
  - Column name: CountryCode, Type: String
  */

  -- Creates a new table with Base64-encoded SHA-256 hashes of specified columns.
  CREATE TABLE `your_project_name.your_dataset_name.output_hashed_table_name`
  AS
  SELECT
    UserID,
    TO_BASE64(SHA256(LOWER(Email))) AS Email,
    TO_BASE64(SHA256(Phone)) AS Phone,
    TO_BASE64(SHA256(LOWER(FirstName))) AS FirstName,
    TO_BASE64(SHA256(LOWER(LastName))) AS LastName,
    PostalCode,
    CountryCode,
  FROM
    `your_project_name.your_dataset_name.input_unhashed_table_name`;

Clés de jointure

Certaines combinaisons de données fournies par l'utilisateur sont plus efficaces que d'autres. Vous trouverez ci-dessous une liste des différentes combinaisons de données fournies par l'utilisateur, classées par force relative. Si vous utilisez une adresse, vous devez inclure les éléments suivants: prénom, nom, pays et code postal.

  1. E-mail, téléphone, adresse (plus efficace)
  2. Téléphone, adresse
  3. Adresse e-mail, adresse
  4. E-mail, téléphone
  5. Adresse
  6. Téléphone
  7. E-mail (le moins sécurisé)

Créer un tableau de correspondance

  1. Cliquez sur Rapports > Créer un rapport > Génération d'une table des correspondances dans un cloud privé > Utiliser un modèle. facultative: Vous pouvez sélectionner Génération d'une table des correspondances dans un cloud privé avec hachage si vos données ne sont pas déjà hachées.

    // Create a new match table using your first party data with this template.

/* Parameters:
Manually remove all the parameters tagged with @ prefix and replace them with
column names from your first party table:
*   @user_id
*   @email
*   @phone
*   @first_name
*   @last_name
*   @country_code
*   @postal_code

And your BigQuery table information:
*   @my_project: Your BigQuery project where the first party table is.
*   @my_dataset: Your dataset where the first party table is.
*   @my_first_party_table: Your first party table.
*/

CREATE OR REPLACE TABLE adh.updm_match_table AS (
SELECT CAST(@user_id AS BYTES) AS user_id,
      @email AS email,
      @phone AS phone,
      @first_name AS first_name,
      @last_name AS last_name,
      @country_code AS country,
      @postal_code AS zip_code
FROM `@my_project.@my_dataset.@my_first_party_table`
);

  2. Remplacez les noms de paramètres par les noms de vos colonnes pour fournir un alias approprié.

  3. Activez le paramètre de confidentialité du bruit sur "Utiliser les vérifications diff".

  4. Cliquez sur Définir une planification pour définir la fréquence d'actualisation de votre table des correspondances. Chaque exécution écrase la table des correspondances actuelle.

Interroger les données mises en correspondance

Interroger les tables des correspondances

Lorsque vos tables de correspondance contiennent suffisamment de données pour satisfaire aux contrôles de confidentialité, vous êtes prêt à exécuter des requêtes sur les tables.

La table d'origine des données first party (1PD) est représentée par my_data. Cela inclut à la fois les informations permettant d'identifier personnellement l'utilisateur et les données non permettant d'identifier personnellement l'utilisateur. L'utilisation du tableau d'origine peut améliorer vos rapports en fournissant plus d'insights, car il représente toutes les données de la table de données de première partie en comparaison avec une table des correspondances.

Chaque table du schéma Ads Data Hub contenant un champ user_id est accompagnée d'une table des correspondances. Par exemple, pour la table adh.google_ads_impressions, Ads Data Hub génère également une table des correspondances appelée adh.google_ads_impressions_updm qui contient vos ID utilisateur. Des tables des correspondances distinctes sont créées pour les tables isolées conformément au règlement. Par exemple, pour la table adh.google_ads_impressions_policy_isolated_youtube, Ads Data Hub génère également une table des correspondances appelée adh.google_ads_impressions_policy_isolated_youtube_updm qui contient vos ID utilisateur.

Ces tables incluent un sous-ensemble des utilisateurs disponibles dans les tables d'origine, où il existe une correspondance avec le user_id. Par exemple, si la table d'origine contient des données pour les utilisateurs A et B, mais que seul l'utilisateur A correspond, l'utilisateur B ne figurera pas dans la table des correspondances.

Les tables des correspondances contiennent une colonne supplémentaire appelée customer_data_user_id, qui stocke l'identifiant utilisateur sous la forme d'OCTETS.

Il est important de prendre en compte le type de champ lorsque vous rédigez vos requêtes. Les opérateurs de comparaison SQL s'attendent à ce que les littéraux que vous comparez soient du même type. Selon la manière dont le user_id est stocké dans votre table de données first party, vous devrez peut-être encoder les valeurs dans la table avant de faire correspondre les données. Vous devez caster votre clé de jointure en OCTETS pour que la mise en correspondance fonctionne :

JOIN ON
  adh.google_ads_impressions_updm.customer_data_user_id = CAST(my_data.user_id AS BYTES)

De plus, les comparaisons de chaînes en SQL sont sensibles à la casse. Par conséquent, vous devrez peut-être encoder les chaînes des deux côtés pour pouvoir les comparer avec précision.

Exemples de requêtes

Compter les utilisateurs correspondants

Cette requête compte le nombre d'utilisateurs mis en correspondance dans votre table des impressions Google Ads.

/* Count matched users in Google Ads impressions table */

SELECT COUNT(DISTINCT user_id)
FROM adh.google_ads_impressions_updm

Calculer le taux de correspondance

Tous les utilisateurs ne peuvent pas être mis en correspondance. Par exemple, les utilisateurs déconnectés, les enfants et les utilisateurs qui n'ont pas donné leur consentement ne sont pas mis en correspondance via l'UPDM. Vous pouvez utiliser le champ is_updm_eligible pour calculer des taux de correspondance UPDM plus précis. Notez que le champ is_updm_eligible est disponible depuis le 1er octobre 2024. Vous ne pouvez pas utiliser ce champ pour calculer les taux de correspondance avant cette date.

/* Calculate the UPDM match rate */

CREATE TEMP TABLE total_events OPTIONS(privacy_checked_export=TRUE) AS
SELECT
  customer_id,
  COUNT(*) AS n
FROM adh.google_ads_impressions
WHERE is_updm_eligible
GROUP BY 1;

CREATE TEMP TABLE matched_events OPTIONS(privacy_checked_export=TRUE) AS
SELECT
  customer_id,
  COUNT(*) AS n
FROM adh.google_ads_impressions_updm
GROUP BY 1;

SELECT
  customer_id,
  SAFE_DIVIDE(matched_events.n, total_events.n) AS match_rate
FROM total_events
LEFT JOIN matched_events
  USING (customer_id)

Associer des données first party et Google Ads

Cette requête montre comment joindre des données first party à des données Google Ads:

/* Join first-party data with Google Ads data. The customer_data_user_id field
contains your ID as BYTES. You need to cast your join key into BYTES for
successful matches. */

SELECT
  inventory_type,
  COUNT(*) AS impressions
FROM
  adh.yt_reserve_impressions_updm AS google_data_imp
LEFT JOIN
  `my_data`
ON
  google_data_imp.customer_data_user_id = CAST(my_data.user_id AS BYTES)
GROUP BY
  inventory_type

Questions fréquentes sur le MCDFU

Pour obtenir la liste des questions fréquentes sur l'UPDM, consultez les questions fréquentes sur l'UPDM.