Detección de fraudes con BigQuery Graph

1. Introducción

Encabezado de marketing: Fraude en Fintech

La actividad fraudulenta suele involucrar redes ocultas de entidades conectadas, por ejemplo, varias cuentas que comparten la misma dirección de correo electrónico, número de teléfono o dirección física. Las bases de datos relacionales tradicionales pueden tener dificultades para consultar estas relaciones complejas de varios saltos de manera eficiente.

BigQuery Graph te permite analizar estas redes a gran escala con bases de datos de grafos. Puedes definir un gráfico de propiedades sobre tus tablas de BigQuery existentes y usar el lenguaje de consultas de gráficos (GQL) para encontrar patrones en tus datos.

Una aplicación común de las redes de grafos para la detección de fraude es detener los pedidos que tienen una dirección de entrega asociada con una red de fraude o detener los pagos que pertenecen a .

En este codelab, compilarás una solución de detección de fraudes con BigQuery Graph. Cargarás datos de Cloud Storage, crearás un gráfico de propiedades y usarás consultas de gráficos para identificar conexiones sospechosas.

Qué aprenderás

Cómo crear un conjunto de datos de BigQuery y cargar datos
Cómo definir un gráfico de propiedades con DDL
Cómo consultar el gráfico con GQL
Cómo usar las estadísticas de grafos para detectar fraudes

Requisitos

Un proyecto de Google Cloud con facturación habilitada.
Un entorno de notebook de BigQuery (BigQuery Studio o Colab Enterprise)

Costo

En este lab, se usan recursos facturables de Google Cloud. El costo estimado es inferior a USD 5, suponiendo que borres los recursos después de completar el proceso.

2. Antes de comenzar

Selecciona o crea un proyecto de Google Cloud

En la página del selector de proyectos de Google Cloud Console, selecciona o crea un proyecto de Google Cloud.
Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud. Obtén información para verificar si la facturación está habilitada.

Elige tu entorno

Necesitarás un entorno de notebook para ejecutar este lab. Puedes usar BigQuery Studio o Colab Enterprise.

Navega a la página de BigQuery en la consola de Google Cloud.
Usarás el notebook de Python para ejecutar las consultas de gráficos.

Inicie Cloud Shell

Haz clic en Activar Cloud Shell en la parte superior de la consola de Google Cloud.
Verifica la autenticación:

gcloud auth list

Confirma tu proyecto:

gcloud config get project

Establécela si es necesario:

export PROJECT_ID=<YOUR_PROJECT_ID>
gcloud config set project $PROJECT_ID

Habilita las APIs

Ejecuta este comando para habilitar la API de BigQuery requerida:

gcloud services enable bigquery.googleapis.com

3. Cargar datos

En este paso, crearás un conjunto de datos de BigQuery y cargarás los datos de muestra desde Cloud Storage.

Los datos de muestra constan de varios archivos CSV que representan un entorno minorista simulado:

customers.csv: Es la información de la cuenta del cliente.
emails.csv: Direcciones de correo electrónico
phones.csv: Números de teléfono.
addresses.csv: Direcciones físicas
customer_emails.csv, customer_phones.csv, customer_addresses.csv: Tablas de vinculación.
orders.csv: Historial de pedidos, incluidas las marcas de fraude.

Crea el conjunto de datos

Crea un conjunto de datos llamado fraud_demo para almacenar las tablas.

En este codelab, ejecutaremos comandos SQL. Puedes ejecutar estos comandos en BigQuery Studio > Editor de SQL o usar el comando bq query en Cloud Shell. Supondremos que usas el editor de SQL de BigQuery para disfrutar de una mejor experiencia con las instrucciones de creación de varias líneas.

CREATE SCHEMA IF NOT EXISTS `fraud_demo` OPTIONS(location="US");

Tablas de carga

Ejecuta las siguientes instrucciones SQL para cargar datos de Cloud Storage en tu conjunto de datos.

LOAD DATA OVERWRITE `fraud_demo.customers`
FROM FILES (
  format = 'CSV',
  uris = ['gs://sample-data-and-media/fraud-demo-data/customers.csv'],
  skip_leading_rows = 1
);

LOAD DATA OVERWRITE `fraud_demo.emails`
FROM FILES (
  format = 'CSV',
  uris = ['gs://sample-data-and-media/fraud-demo-data/emails.csv'],
  skip_leading_rows = 1
);

LOAD DATA OVERWRITE `fraud_demo.phones`
FROM FILES (
  format = 'CSV',
  uris = ['gs://sample-data-and-media/fraud-demo-data/phones.csv'],
  skip_leading_rows = 1
);

LOAD DATA OVERWRITE `fraud_demo.addresses`
FROM FILES (
  format = 'CSV',
  uris = ['gs://sample-data-and-media/fraud-demo-data/addresses.csv'],
  skip_leading_rows = 1
);

LOAD DATA OVERWRITE `fraud_demo.customer_emails`
FROM FILES (
  format = 'CSV',
  uris = ['gs://sample-data-and-media/fraud-demo-data/customer_emails.csv'],
  skip_leading_rows = 1
);

LOAD DATA OVERWRITE `fraud_demo.customer_phones`
FROM FILES (
  format = 'CSV',
  uris = ['gs://sample-data-and-media/fraud-demo-data/customer_phones.csv'],
  skip_leading_rows = 1
);

LOAD DATA OVERWRITE `fraud_demo.customer_addresses`
FROM FILES (
  format = 'CSV',
  uris = ['gs://sample-data-and-media/fraud-demo-data/customer_addresses.csv'],
  skip_leading_rows = 1
);

LOAD DATA OVERWRITE `fraud_demo.orders`
FROM FILES (
  format = 'CSV',
  uris = ['gs://sample-data-and-media/fraud-demo-data/orders.csv'],
  skip_leading_rows = 1
);

4. Crea el gráfico de propiedad

Ahora que los datos están cargados, puedes definir el gráfico de propiedades. Un grafo de propiedades consta de nodos (entidades) y aristas (relaciones).

En este lab, los nodos son los siguientes:

Cliente: Representa al titular de la cuenta.
Teléfono: Representa un número de teléfono.
Correo electrónico: Representa una dirección de correo electrónico.
Address: Representa una dirección física.

Las aristas son las siguientes:

OwnsPhone: Conecta un cliente a un teléfono.
OwnsEmail: Conecta un cliente a un correo electrónico.
LinkedToAddress: Conecta un cliente a una dirección.

Crea el gráfico

Ejecuta la siguiente instrucción DDL para crear el gráfico llamado FraudDemo en tu conjunto de datos fraud_demo.

CREATE OR REPLACE PROPERTY GRAPH fraud_demo.FraudDemo
  NODE TABLES(
    fraud_demo.customers
      KEY(account_id)
      LABEL Customer PROPERTIES(
        account_id,
        name),

    fraud_demo.emails
      KEY(email)
      LABEL Email PROPERTIES(
        email,
        email_type),

    fraud_demo.phones
      KEY(phone_number)
      LABEL Phone PROPERTIES(
        phone_number,
        phone_type),

    fraud_demo.addresses
      KEY(address)
      LABEL Address PROPERTIES(
        address,
        address_type)
  )
  EDGE TABLES(
    fraud_demo.customer_emails
      KEY(account_id, email)
      SOURCE KEY(account_id) REFERENCES customers(account_id)
      DESTINATION KEY(email) REFERENCES emails(email)
      LABEL OwnsEmail PROPERTIES(
        account_id,
        email,
        last_updated_ts),

    fraud_demo.customer_phones
      KEY(account_id, phone_number)
      SOURCE KEY(account_id) REFERENCES customers(account_id)
      DESTINATION KEY(phone_number) REFERENCES phones(phone_number)
      LABEL OwnsPhone PROPERTIES(
        account_id,
        phone_number,
        last_updated_ts),

    fraud_demo.customer_addresses
      KEY(account_id, address)
      SOURCE KEY(account_id) REFERENCES customers(account_id)
      DESTINATION KEY(address) REFERENCES addresses(address)
      LABEL LinkedToAddress PROPERTIES(
        account_id,
        address,
        last_updated_ts)
  );

5. Analizar redes (2 saltos)

Abre New Notebook en BigQuery Studio.

Crear notebook nuevo

Para las partes de visualización y recomendación de este codelab, usaremos un notebook de Google Colab en BigQuery Studio. Esto nos permite visualizar fácilmente los resultados del gráfico.

El notebook de gráficos de BigQuery se implementa como un comando mágico de IPython. Si agregas el comando mágico %%bigquery con la función TO_JSON, puedes visualizar los resultados como se muestra en las siguientes secciones. En este paso, ejecutarás una consulta de gráfico para encontrar conexiones simples entre cuentas. Esta es una búsqueda de "2 saltos" porque viaja 2 saltos desde un nodo inicial para encontrar nodos relacionados (p.ej., Cliente -> Correo electrónico -> Cliente).

Comenzaremos investigando la cuenta de Nicole Wade. Queremos encontrar cualquier cuenta relacionada con ella a través de 2 saltos.

Ejecuta la consulta de 2 saltos

Ejecuta la siguiente consulta en tu notebook.

%%bigquery --graph
GRAPH fraud_demo.FraudDemo
MATCH 
 p=(a:Customer) 
  ( -[e:OwnsEmail|OwnsPhone|LinkedToAddress WHERE e.last_updated_ts < '2025-07-30']- (n) ){2}
WHERE a.account_id IN ("d2f1f992-d116-41b3-955b-6c76a3352657")
  -- Verify the final node in the hop array is a Customer
  AND 'Customer' IN UNNEST(LABELS(n[OFFSET(1)]))

RETURN TO_JSON(p) AS paths

Cómo comprender los resultados

La consulta realiza las siguientes acciones:

Comienza en el nodo Customer con account_id "d2f1f992-d116-41b3-955b-6c76a3352657" (Nicole Wade).
Sigue cualquiera de las aristas OwnsEmail, OwnsPhone o LinkedToAddress hasta un nodo de conexión (Phone, Email o Address).
Sigue los bordes hacia atrás desde ese nodo de conexión hasta otros nodos Customer.
Filtra las aristas según una marca de tiempo (last_updated_ts) para ver el estado de la red en un momento específico.

Deberías ver que Zachary Cordova y Brenda Brown están conectados a Nicole a través de la misma dirección.

6. Analizar redes (4 saltos)

En este paso, extenderás la consulta para encontrar relaciones más complejas. Buscaremos conexiones de 4 saltos. Esto nos permite encontrar cuentas que están conectadas a través de varias entidades intermedias (p.ej., Cliente A -> Correo electrónico -> Cliente B -> Teléfono -> Cliente C).

También observaremos cómo cambia esta red con el tiempo.

El estado "Antes"

Primero, veamos la red tal como existía el 30 de julio de 2025.

Ejecute la siguiente consulta:

%%bigquery --graph
%%bigquery --graph

MATCH p= ANY SHORTEST (a:Customer) 
  ( -[e:OwnsEmail|OwnsPhone|LinkedToAddress WHERE e.last_updated_ts < '2025-07-30']- (n) ){3, 5}(reachable_a:Customer)
WHERE a.account_id IN ("d2f1f992-d116-41b3-955b-6c76a3352657")
  -- Ensure the final node in the dynamic chain is actually a Customer
  AND 'Customer' IN UNNEST(LABELS(n[OFFSET(ARRAY_LENGTH(n) - 1)]))
GRAPH fraud_demo.FraudDemo
RETURN 
  TO_JSON(p) AS paths,                   -- Array of all traversed edges
  ARRAY_LENGTH(e) AS hop_count

El estado "Después"

Ahora, veamos cómo se ve la red 2 semanas después. Ejecutaremos la misma consulta, pero sin las restricciones de fecha.

Ejecute la siguiente consulta:

%%bigquery --graph
GRAPH fraud_demo.FraudDemo
MATCH p= ANY SHORTEST (a:Customer) 
  ( -[e:OwnsEmail|OwnsPhone|LinkedToAddress]- (n) ){3, 5}(reachable_a:Customer)
WHERE a.account_id IN ("d2f1f992-d116-41b3-955b-6c76a3352657")
  -- Ensure the final node in the dynamic chain is actually a Customer
  AND 'Customer' IN UNNEST(LABELS(n[OFFSET(ARRAY_LENGTH(n) - 1)]))

RETURN 
  TO_JSON(p) AS paths,                   -- Array of all traversed edges
  ARRAY_LENGTH(e) AS hop_count

Cómo comprender los resultados

Si quitas los filtros de fecha, realizarás la consulta en el conjunto de datos completo. Notarás que la red creció significativamente. Nicole Wade ahora forma parte de un grupo mucho más grande y conectado. Esta rápida expansión de una red conectada es un indicador sólido de actividad potencialmente fraudulenta, como un anillo de fraude que comparte recursos con el tiempo.

7. Generar informe de fraude

En este paso, combinarás el análisis de gráficos con los datos comerciales tradicionales (pedidos) para generar un informe de fraude integral. Identificarás las cuentas en riesgo y los posibles pedidos fraudulentos.

Esta búsqueda es más compleja. Usa GRAPH_TABLE para ejecutar la consulta de gráfico dentro de SQL estándar y calcula el cambio en el tamaño de la red (diff) entre los estados "antes" y "después" que observamos en el paso anterior.

Ejecuta la consulta del informe de fraude

Ejecuta la siguiente consulta en tu notebook.

%%bigquery --graph
WITH num_orders AS (
  SELECT account_id, COUNT(1) AS num_order
  FROM fraud_demo.orders
  WHERE order_time > '2025-07-30'
  GROUP BY account_id
),

orders AS (
  SELECT account_id, order_id, fraud, order_total
  FROM fraud_demo.orders
  WHERE order_time > '2025-07-30'
),

-- Use Quantified Path Patterns to find connections up to 4 hops away
latest_connect AS (
  SELECT 
    account_id, 
    ARRAY_LENGTH(ARRAY_AGG(DISTINCT connected_id)) AS size
  FROM GRAPH_TABLE(
    fraud_demo.FraudDemo
    MATCH (a:Customer)-[:OwnsEmail|OwnsPhone|LinkedToAddress]-{4}(connected:Customer)
    RETURN a.account_id AS account_id, connected.account_id AS connected_id
  )
  GROUP BY account_id
),

prev_connect AS (
  SELECT 
    account_id, 
    ARRAY_LENGTH(ARRAY_AGG(DISTINCT connected_id)) AS size
  FROM GRAPH_TABLE(
    fraud_demo.FraudDemo
    -- Apply the timestamp filter to EVERY edge in the 4-hop chain
    MATCH (a:Customer)
          (-[e:OwnsEmail|OwnsPhone|LinkedToAddress WHERE e.last_updated_ts < '2025-07-30']-(n)){4}
    WHERE 'Customer' IN UNNEST(LABELS(n[OFFSET(3)]))
    RETURN a.account_id AS account_id, n[OFFSET(3)].account_id AS connected_id
  )
  GROUP BY account_id
),

edge_changes AS (
  SELECT account_id, MAX(last_updated_ts) AS max_last_updated_ts
  FROM fraud_demo.customer_addresses
  GROUP BY account_id
)

SELECT
    la.account_id,
    o.order_id,
    la.size AS latest_size,
    COALESCE(pa.size, 0) AS previous_size,
    la.size - COALESCE(pa.size, 0) AS diff,
    nos.num_order,
    o.fraud AS reported_as_fraud,
    o.order_total,

    CASE
      WHEN (la.size - COALESCE(pa.size, 0)) > 10 AND nos.num_order IS NULL THEN "CUSTOMER AT RISK"
      WHEN (la.size - COALESCE(pa.size, 0)) > 10 AND nos.num_order IS NOT NULL AND o.fraud THEN "CONFIRMED FRAUD ORDER"
      WHEN (la.size - COALESCE(pa.size, 0)) > 10 AND nos.num_order IS NOT NULL AND NOT o.fraud THEN "POTENTIAL FRAUD ORDER"
      ELSE ""
    END AS notes
FROM latest_connect la
LEFT JOIN prev_connect pa ON la.account_id = pa.account_id
LEFT JOIN num_orders nos ON la.account_id = nos.account_id
LEFT JOIN orders o ON la.account_id = o.account_id
INNER JOIN edge_changes ec ON la.account_id = ec.account_id
WHERE nos.num_order > 1 OR (la.size - COALESCE(pa.size, 0)) > 10
ORDER BY diff DESC

Cómo comprender los resultados

En este informe, se muestra lo siguiente:

account_id: Es el ID de la cuenta que se analiza.
order_id: ID de un pedido reciente.
latest_size: Es el tamaño de la red conectada hoy.
previous_size: Es el tamaño de la red hace 2 semanas.
diff: Es el crecimiento en el tamaño de la red.
num_order: Es la cantidad de pedidos recientes.
reported_as_fraud: Indica si el pedido se marcó como fraudulento.
order_total: Es el importe total del pedido.
notes: Es un estado de riesgo calculado en función del crecimiento de la red y el historial de pedidos.

Verás cuentas con valores de diff grandes y totales de pedidos altos, que son candidatos ideales para una mayor investigación. Las notas "CLIENTE EN RIESGO" y "PEDIDO POTENCIALMENTE FRAUDULENTO" ayudan a priorizar estas cuentas.

8. Detección a gran escala

En este último paso del análisis, visualizarás la red a mayor escala. En lugar de comenzar con una sola cuenta, consultarás las conexiones entre un conjunto de cuentas sospechosas.

Esto te ayuda a ver si varias investigaciones independientes son, en realidad, parte de la misma red de fraude más grande.

Ejecuta la consulta escalada

Ejecuta la siguiente consulta en tu notebook.

%%bigquery --graph
GRAPH fraud_demo.FraudDemo
MATCH
p= ANY SHORTEST (a:Customer) 
  ( -[e:OwnsEmail|OwnsPhone|LinkedToAddress]- (n) ){3, 5}
(reachable_a:Customer)
-- these IDs are from the previous results
WHERE a.account_id in (   "845f2b14-cd10-4750-9f28-fe542c4a731b"
  , "3ff59684-fbf9-40d7-8c41-285ade5002e6"
  , "8887c17b-e6fb-4b3b-8c62-cb721aafd028"
  , "03e777e5-6fb4-445d-b48c-cf42b7620874"
  , "81629832-eb1d-4a0e-86da-81a198604898"
  , "845f2b14-cd10-4750-9f28-fe542c4a731b",
   "89e9a8fe-ffc4-44eb-8693-a711a3534849"
 )
 LIMIT 400
RETURN TO_JSON(p) as paths

Cómo comprender los resultados

Esta consulta devuelve un gráfico complejo que muestra cómo se superponen y comparten recursos las cuentas sospechosas especificadas. Ahora puedes ver la detección de fraude a gran escala, que identifica clústeres de actividad que podrían justificar una respuesta coordinada.

9. Limpieza

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos que usaste en este codelab, debes borrar el conjunto de datos y el gráfico de propiedades.

Ejecuta las siguientes instrucciones de SQL para limpiar tu entorno.

DROP PROPERTY GRAPH IF EXISTS fraud_demo.FraudDemo;
DROP SCHEMA IF EXISTS fraud_demo CASCADE;

10. Felicitaciones

¡Felicitaciones! Creaste correctamente una solución de detección de fraude con BigQuery Graph.

Aprendiste a realizar las siguientes actividades:

Cargar datos de Cloud Storage en BigQuery
Define un gráfico de propiedades con DDL.
Consulta el gráfico con GQL para encontrar relaciones simples y complejas.
Combina el análisis de gráficos con los datos de la empresa para identificar riesgos.
Visualiza redes a gran escala.

Más recursos

Documentación de BigQuery Graph

Detección de fraudes con BigQuery Graph Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

1. Introducción

Qué aprenderás

Requisitos

Costo

2. Antes de comenzar

Selecciona o crea un proyecto de Google Cloud

Elige tu entorno

Inicie Cloud Shell

Habilita las APIs

3. Cargar datos

Crea el conjunto de datos

Tablas de carga

4. Crea el gráfico de propiedad

Crea el gráfico

5. Analizar redes (2 saltos)

Ejecuta la consulta de 2 saltos

Cómo comprender los resultados

6. Analizar redes (4 saltos)

El estado "Antes"

El estado "Después"

Cómo comprender los resultados

7. Generar informe de fraude

Ejecuta la consulta del informe de fraude

Cómo comprender los resultados

8. Detección a gran escala

Ejecuta la consulta escalada

Cómo comprender los resultados

9. Limpieza

10. Felicitaciones

Más recursos

Detección de fraudes con BigQuery Graph