Correlación de datos proporcionados por el usuario

La correlación de datos proporcionados por el usuario (UPDM) une los datos de origen que recopilaste sobre un usuario (como la información proveniente de tus sitios web, apps o tiendas físicas) con la actividad que se registra en los datos de anuncios de Google, incluidos los datos que Google posee y opera. Esto incluye los datos que se compran a través de los productos de Google Marketing Platform (GMP), por ejemplo, YouTube comprado con Display & Video 360. No se admiten otros productos de GMP que no sean propiedad de Google ni estén operados por Google.

Para poder utilizar la correlación de datos proporcionados por el usuario, el evento de anuncio debe estar vinculado a un usuario que haya accedido a su cuenta y figure en los datos de anuncios de Google.

En este documento, se describe la función de coincidencia de datos proporcionados por el usuario y se proporciona orientación sobre su configuración y uso.

Descripción general de la concordancia de nube privada

Para obtener estadísticas publicitarias valiosas, a menudo es necesario combinar datos de varias fuentes. Crear tu propia solución para este problema de canalización de datos requiere una inversión significativa de tiempo y de ingeniería. La Segmentación por Cloud privada en el Centro de Datos de Anuncios optimiza este proceso, ya que proporciona una plantilla de consulta del Centro de Datos de Anuncios para crear una tabla de coincidencias en BigQuery que se puede usar en tus consultas del Centro de Datos de Anuncios para hacer coincidir tus datos de anuncios con tus datos de origen. Enriquecer tus consultas con datos de origen puede ofrecer experiencias del cliente más enriquecidas y es más resistente a los cambios en el seguimiento de anuncios en toda la industria.

Debido a que la coincidencia de datos proporcionados por el usuario solo está disponible en el inventario administrado y propiedad de Google para los usuarios que accedieron a sus cuentas, no se verá afectada por la próxima baja de las cookies de terceros. Dado que es más resistente a los cambios en el sector que los datos de terceros, puede proporcionar estadísticas más detalladas, lo que puede generar una mayor participación de los clientes.

Resumen del proceso

  1. Configuración de la transferencia y la coincidencia de datos
  2. Transferencia y coincidencia de datos de origen
    • Tú debes dar formato a tus datos de origen y subirlos a tu conjunto de datos de BigQuery.
    • Para iniciar una solicitud de coincidencia de datos, crea una consulta de análisis de coincidencias de Cloud Private y establece un programa.
    • Google une los datos de tu proyecto con los datos que pertenecen a Google, que contienen el ID de usuario de Google y los datos proporcionados por el usuario con codificación hash, para crear y actualizar las tablas de coincidencias.
    • Consulta Cómo transferir datos de origen
  3. Consultas en curso en el Centro de Datos de Anuncios, según los datos coincidentes
    • Ejecutas consultas en las tablas de coincidencias de la misma manera que ejecutas consultas normales en el Centro de Datos de Anuncios. Consulta Cómo consultar datos coincidentes.

Más información sobre los requisitos de privacidad

Recopilación de datos de los clientes

Cuando utilizas la Segmentación por datos proporcionados por el usuario, debes subir datos de origen. Esta podría ser información que recopilaste de tus sitios web, aplicaciones, tiendas físicas o cualquier información que un cliente te haya compartido directamente.

Obligaciones:

  • Asegúrate de que tu política de privacidad divulgue que compartes los datos de los clientes con terceros que prestan servicios en tu nombre, además de obtener el consentimiento para compartirlos cuando así lo exija la ley.
  • Debe utilizar solo la interfaz o la API de Google aprobadas para subir los datos de clientes.
  • Debe satisfacer todas las leyes y reglamentaciones aplicables, incluido cualquier código autorregulatorio o de la industria que se pudiera aplicar.

Confirmación del consentimiento propio

Para asegurarte de poder usar tus datos de origen en el Centro de Datos de Anuncios, debes confirmar que obtuviste el consentimiento adecuado para compartir los datos de los usuarios finales del EEE con Google de conformidad con la Política de Consentimiento de Usuarios de la UE y la política del Centro de Datos de Anuncios. Este requisito se aplica a cada cuenta de Ads Data Hub y se debe actualizar cada vez que subas datos de origen nuevos. Cualquier usuario puede realizar este reconocimiento en nombre de toda la cuenta.

Ten en cuenta que las mismas reglas de consulta de los servicios de Google que se aplican a las consultas de análisis también se aplican a las consultas de la UPDM. Por ejemplo, no puedes ejecutar consultas entre servicios en usuarios del EEE cuando creas una tabla de coincidencias.

Si deseas obtener información para confirmar el consentimiento en el Centro de datos de anuncios, consulta Requisitos de consentimiento para el Espacio Económico Europeo.

Tamaño de los datos

Para proteger la privacidad del usuario final, la coincidencia de datos proporcionados por el usuario aplica estos requisitos en relación con el tamaño de tus datos:

  • Debes subir al menos 1,000 registros en tu lista de usuarios.
  • La lista no debe superar la cantidad máxima de registros. Para obtener información sobre el límite máximo de datos, comunícate con tu representante de Google.

Configura la transferencia de datos

Antes de comenzar, asegúrate de lo siguiente:

  • Tus datos de origen deben estar en BigQuery. Si tienes un perímetro de VPC-SC, estos datos de origen deben estar dentro de tu VPC-SC.
  • Tu cuenta de servicio de Ads Data Hub debe tener acceso de lectura a los datos de origen.
  • Tus datos de origen deben tener el formato correcto y la codificación hash correcta. Consulta la siguiente sección para obtener más detalles.

Además, Private Cloud Match no tiene integración adicional. Si puedes ejecutar una consulta de análisis, puedes ejecutar una consulta de coincidencia de Cloud privado.

Transferencia y coincidencia de datos de origen

Da formato a los datos de entrada

Para que tus datos coincidan correctamente, deben cumplir con estos requisitos de formato:

  • Cuando se indique en las siguientes descripciones de campos de entrada, debes subir el archivo con el hash SHA256.
  • Los campos de entrada deben tener el formato de cadena. Por ejemplo, si usas la función de hash SHA256 de BigQuery con la función de codificación Base64 (TO_BASE64), usa la siguiente transformación: TO_BASE64(SHA256(user_data)).
  • UPDM admite la codificación Base64. Debes alinear la codificación de tus datos de origen con la decodificación que se usa en tu consulta del Centro de Datos de Anuncios. Si cambias la codificación de tus datos propios, debes actualizar la consulta de Ads Data Hub para decodificar desde la misma base. En los siguientes ejemplos, se usa la codificación Base64.

ID de usuario

  • Texto sin formato
  • Hashing: Ninguno

Correo electrónico

  • Quita los espacios en blanco iniciales y finales
  • Escribe todos los caracteres en minúscula.
  • Incluye un nombre de dominio para todas las direcciones de correo electrónico, como gmail.com o hotmail.co.jp.
  • Quita los acentos. Por ejemplo, cambia è, é, ê o ë a e.
  • Quita todos los puntos (.) que anteceden al nombre de dominio en las direcciones de correo electrónico gmail.com y googlemail.com.
  • Hashing: SHA256 codificado en Base64

Válido: TO_BASE64(SHA256("jeffersonloveshiking@gmail.com"))

No válida: TO_BASE64(SHA256(" Jéfferson.Lôves.Hiking@gmail.com "))

Teléfono

  • Quita los espacios en blanco
  • Usa el formato E.164. Ejemplo de EE.UU.: +14155552671; ejemplo del Reino Unido: +442071838750
  • Quita todos los caracteres especiales, excepto el signo “+” que antecede al código de país.
  • Hashing: SHA256 codificado en Base64

Válido: TO_BASE64(SHA256("+18005550101"))

No válida: TO_BASE64(SHA256("(800) 555-0101"))

Nombre

  • Quita los espacios en blanco
  • Escribe todos los caracteres en minúscula.
  • Quita todos los prefijos, por ejemplo, Sra., Sr. Srta. Dr.
  • No quites los acentos, por ejemplo, è, é, ê o ë.
  • Hashing: SHA256 codificado en Base64

Válido: TO_BASE64(SHA256("daní"))

No válida: TO_BASE64(SHA256("Mrs. Daní"))

Apellido

  • Quita los espacios en blanco
  • Escribe todos los caracteres en minúscula.
  • Quita todos los sufijos, por ejemplo, Jr. Sr. 2º, 3º, II, III, PHD, MD
  • No quites los acentos, por ejemplo, è, é, ê o ë.
  • Hashing: SHA256 codificado en Base64

Válido: TO_BASE64(SHA256("délacruz"))

No válida: TO_BASE64(SHA256("dé la Cruz, Jr."))

País

  • Incluya el código del país, aun cuando todos los datos de sus clientes correspondan al mismo país.
  • No generes un hash en los datos de país
  • Usa los códigos de país ISO 3166-1 alpha-2
  • Hashing: Ninguno

Válido: US

No válido: United States of America o USA

Código postal

  • No generes un hash en los datos de código postal
  • Se permite el uso tanto de códigos postales estadounidenses como internacionales.
  • Para EE.UU.:
    • Se permiten códigos de 5 dígitos, por ejemplo, 94043.
    • También se permite el uso de códigos de 5 dígitos seguidos de una extensión de 4 dígitos, por ejemplo, 94043-1351 o 940431351.
  • Para todos los demás países:
    • No se necesita formato (no es necesario escribir en minúsculas ni quitar espacios ni caracteres especiales)
    • Omita las extensiones de código postal.
  • Hashing: Ninguno

Validación de hash y codificación de datos

Puedes usar las siguientes secuencias de comandos de validación de hash para asegurarte de que tus datos tengan el formato correcto.

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`;

Claves de unión

Algunas combinaciones de datos proporcionados por el usuario son más sólidas que otras. A continuación, se muestra una lista de las diferentes combinaciones de datos proporcionados por el usuario, clasificadas según su fortaleza relativa. Si usas una dirección, debes incluir el nombre, el apellido, el país y el código postal.

  1. Correo electrónico, teléfono y dirección (más confiables)
  2. Teléfono y dirección
  3. Correo electrónico, dirección
  4. Correo electrónico y teléfono
  5. Dirección
  6. Teléfono
  7. Correo electrónico (menos seguro)

Crea una tabla de coincidencias

  1. Haz clic en Informes > Crear informe > Generación de tablas de coincidencias de la nube privada > Usar plantilla. Opcional: Puedes seleccionar Generación de tablas de coincidencias de la nube privada con hash si tus datos aún no tienen hash.

    // 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. Reemplaza los nombres de los parámetros por los nombres de tus columnas para proporcionar un alias adecuado.

  3. Activa la configuración de ruido de privacidad en "Usar verificaciones de diferencias".

  4. Haz clic en Establecer programación para establecer la frecuencia con la que deseas que se actualice la tabla de coincidencias. Cada ejecución reemplazará la tabla de coincidencias actual.

Cómo consultar datos coincidentes

Consulta las tablas de coincidencias

Cuando tus tablas de coincidencias contengan suficientes datos para satisfacer las verificaciones de privacidad, podrás ejecutar consultas en ellas.

La tabla original de los datos de origen (1PD) se representa con my_data. Esto incluye la información de identificación personal (PII) y los datos que no son PII. El uso de la tabla original puede mejorar tus informes con más estadísticas, ya que representa todos los datos de 1PD en el alcance, en comparación con una tabla de coincidencias.

Cada tabla del esquema del Centro de Datos de Anuncios que contiene un campo user_id se acompaña de una tabla de concordancia. Por ejemplo, para la tabla adh.google_ads_impressions, el Centro de Datos de Anuncios también genera una tabla de coincidencias llamada adh.google_ads_impressions_updm que contiene tus IDs de usuario. Se crean tablas de coincidencias independientes para las tablas aisladas por políticas. Por ejemplo, para la tabla adh.google_ads_impressions_policy_isolated_youtube, el Centro de Datos de Anuncios también genera una tabla de coincidencias llamada adh.google_ads_impressions_policy_isolated_youtube_updm que contiene tus IDs de usuario.

Estas tablas contienen un subconjunto de los usuarios disponibles en las tablas originales, en las que hay una coincidencia en user_id. Por ejemplo, si la tabla original contiene datos del Usuario A y del Usuario B, pero solo se encuentra una coincidencia para el Usuario A, el Usuario B no estará en la tabla de coincidencias.

Las tablas de coincidencias contienen una columna adicional llamada customer_data_user_id, que almacena el identificador de usuario como BYTES.

Es importante considerar el tipo de campo cuando escribas tus consultas. Los operadores de comparación de SQL esperan que los literales que comparas sean del mismo tipo. Según cómo se almacene el user_id en tu tabla de datos propios, es posible que debas codificar los valores de la tabla antes de hacer coincidir los datos. Debes transmitir tu clave de unión a BYTES para que las coincidencias se realicen correctamente:

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

Además, las comparaciones de cadenas en SQL distinguen mayúsculas de minúsculas, por lo que es posible que debas codificar cadenas en ambos lados de la comparación para asegurarte de que se puedan comparar con precisión.

Consultas de muestra

Cuenta los usuarios coincidentes

Esta consulta cuenta la cantidad de usuarios coincidentes en tu tabla de impresiones de Google Ads.

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

SELECT COUNT(DISTINCT user_id)
FROM adh.google_ads_impressions_updm

Cómo calcular el porcentaje de coincidencias

No todos los usuarios son aptos para la coincidencia. Por ejemplo, los usuarios que salieron de sus cuentas, los niños y los usuarios que no dieron su consentimiento no se corresponden con la UPDM. Puedes usar el campo is_updm_eligible para calcular tasas de coincidencia de UPDM más precisas. Ten en cuenta que el campo is_updm_eligible estuvo disponible a partir del 1 de octubre de 2024. No puedes usar este campo para calcular las tasas de coincidencia anteriores a esa fecha.

/* 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)

Cómo unir datos de origen y de Google Ads

En esta consulta, se muestra cómo unir datos de origen con datos de 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

Preguntas frecuentes sobre la UPDM

Para obtener una lista de preguntas frecuentes relacionadas con la UPDM, consulta Preguntas frecuentes sobre la UPDM.