How to Analyze Graph Data with BigQuery Graph

BigQuery Graph lets you run graph analysis on data already in BigQuery. You do not need a separate graph database, and your data stays exactly where it is. Google released the feature into public preview on April 14, 2026, with full GQL support and a visual modeler built into BigQuery Studio.

What BigQuery Graph actually does

A graph models data as nodes (entities) and edges (relationships). In a relational database, finding multi-hop relationships, such as accounts that received money from accounts that also received money from a flagged account, requires multiple joins and recursive CTEs that quickly become unreadable. BigQuery Graph handles this natively with GQL pattern syntax.

The key design choice: a property graph in BigQuery is a logical view. When you create one, no data is moved or duplicated. The graph reads directly from your existing tables. You can create it, delete it, and recreate it without touching your source data.

BigQuery Graph implements the ISO GQL standard, which Google helped author. This means the query patterns you write for BigQuery Graph are transferable skills, not a proprietary syntax that locks you in. The standard was published in 2024 and BigQuery is among the first major cloud warehouses to adopt it alongside Spanner.

Prerequisites

• A Google Cloud project with BigQuery API enabled
• BigQuery Studio access (the graph modeler and visualization tools live there)
• Source tables that have clear entity and relationship columns

The feature is in preview and available in US and EU multi-regions. To request access or report issues, email bq-graph-preview-support@google.com.

Step 1: Structure your source tables

BigQuery Graph requires two table types. Node tables represent entities. Edge tables represent relationships between entities and must contain foreign keys pointing back to node table primary keys.

A minimal financial example uses four tables:

• Person (id, name, city)
• Account (id, create_time, is_blocked)
• PersonOwnAccount (id, account_id) -- who owns which account
• AccountTransferAccount (id, to_id, amount, create_time) -- money movements

If your data already lives in BigQuery, you likely have equivalent tables. The column names do not need to match; you map them when creating the graph.

One important constraint: edge tables must have exactly one source key column and one destination key column that reference primary keys in node tables. If your relationship table has composite keys, you will need to either add a surrogate key column or restructure the edge table definition. The BigQuery graph visual modeler in Studio highlights these mapping requirements visually, which is useful when working through a complex schema for the first time.

Step 2: Create a property graph

Run this DDL in BigQuery Studio or via the BigQuery API:

CREATE OR REPLACE PROPERTY GRAPH FinGraph
  NODE TABLES (
    Person,
    Account
  )
  EDGE TABLES (
    PersonOwnAccount
      SOURCE KEY (id) REFERENCES Person (id)
      DESTINATION KEY (account_id) REFERENCES Account (id)
      LABEL Owns,
    AccountTransferAccount
      SOURCE KEY (id) REFERENCES Account (id)
      DESTINATION KEY (to_id) REFERENCES Account (id)
      LABEL Transfers
  );

This creates the graph as a dataset resource. You can inspect it in BigQuery Studio under your dataset, where it shows node and edge tables with their label mappings. No storage cost is incurred beyond normal table storage.

Step 3: Write GQL queries

GQL uses a GRAPH_TABLE function to run graph pattern queries inside standard SQL. The pattern syntax uses parentheses for nodes and brackets for edges.

Find all accounts owned by a person:

SELECT person_id, account_id
FROM GRAPH_TABLE(
  FinGraph
  MATCH (p:Person)-[:Owns]->(a:Account)
  RETURN p.id AS person_id, a.id AS account_id
);

Detect two-hop money flows (potential layering):

SELECT src_id, intermediate_id, dst_id, total_amount
FROM GRAPH_TABLE(
  FinGraph
  MATCH (src:Account)-[t1:Transfers]->(mid:Account)-[t2:Transfers]->(dst:Account)
  WHERE src.id <> dst.id
  RETURN src.id AS src_id,
         mid.id AS intermediate_id,
         dst.id AS dst_id,
         t1.amount + t2.amount AS total_amount
)
ORDER BY total_amount DESC;

This query finds any account that sent money to an intermediate account, which then forwarded money to a third account. In SQL this would require a self-join on the transfers table with aliasing. In GQL, the path pattern makes the intent explicit and the query readable.

Supply chain tracing (find all upstream suppliers for a part):

SELECT part_id, supplier_id, hops
FROM GRAPH_TABLE(
  SupplyGraph
  MATCH (p:Part)<-[:Supplies* 1..5]-(s:Supplier)
  RETURN p.id AS part_id, s.id AS supplier_id,
         LENGTH(MATCH_EDGE_ARRAY()) AS hops
)
ORDER BY hops;

The quantifier * 1..5 traverses up to five hops in one query, something that would require five UNION queries or a recursive CTE in standard SQL.

Step 4: Visualize in BigQuery Studio

After running a GRAPH_TABLE query that returns node and edge data, BigQuery Studio offers a graph view tab alongside the standard table view. Select it to see a force-directed layout of your result set. You can click nodes to inspect properties.

The visual modeler (also in Studio) lets you drag tables onto a canvas and draw edge relationships to generate the CREATE PROPERTY GRAPH statement automatically, which helps when your schema has many tables.

There are a few things the visualization does not yet support in preview: it renders up to 500 nodes per result set before truncating, and it does not support custom color-coding by node property without exporting to a separate tool. For exploratory analysis on moderately sized graphs, the built-in view is sufficient. For large-scale graph visualization, you would need to export query results and use a dedicated tool like Gephi or a notebook with a graph plotting library.

Common use cases

Fraud detection is the most documented application. One financial institution that moved fraud network analysis to a graph approach reported identifying circular transfer rings across 12-hop paths that SQL queries had missed entirely, contributing to roughly 9.1 million pounds in prevented losses. BigQuery Graph makes this analysis available to analysts who already know SQL, without needing a dedicated graph database team.

Customer 360 is another strong fit. Model customers as nodes, purchases and interactions as edges, and run pattern queries to find customers with similar behavior clusters for targeting or churn prediction.

Data lineage tracking is also a natural use case. Map column-level lineage across pipelines by modeling tables as nodes and transformations as edges, then trace upstream dependencies for any output column in one query.

Costs and performance

BigQuery Graph queries are billed the same way as standard BigQuery queries: on bytes processed. The graph definition itself has no ongoing cost. A two-hop GRAPH_TABLE query over a 10-million-row transfers table typically scans the full table, so the same cost optimization rules apply as for regular BigQuery SQL: partition your edge tables by date or region where possible, and use column clustering on the keys you query most.

During the preview period, Google has not published specific performance benchmarks. Early community reports from the Medium series and Google Codelabs suggest that multi-hop queries that previously required 5-minute recursive SQL runs on large datasets can return in under 30 seconds using GQL path quantifiers, primarily because BigQuery can parallelize the graph traversal differently from a recursive CTE.

What BigQuery Graph does not replace

BigQuery Graph runs analytical queries on large datasets. It is not designed for transactional graph workloads that require low-latency single-record lookups at scale. For those workloads, Google offers Spanner Graph. If you need to query the same graph for both analytics and transactional use, you can federate both systems and join results in BigQuery.

Practical summary

BigQuery Graph adds graph pattern matching to a warehouse most data teams already use. Setup takes about 20 minutes if your tables are already in BigQuery: enable the feature, write a CREATE PROPERTY GRAPH statement, and start querying in GQL. The biggest immediate payoff is multi-hop relationship queries that previously required brittle recursive SQL. If you work with financial transactions, operational networks, or customer relationship data, the feature is worth testing during the preview window.

If you want to run ad hoc graph-style questions on a dataset you already have without any setup, VSLZ lets you upload a file and ask relationship questions in plain English, handling the query translation automatically.