GA4 Retention Key Takeaways
- GA4 is a reporting interface, not a data warehouse. Unaggregated event records expire on a fixed schedule, and aggregate standard reports stay indefinitely.
- Two months is the default retention window. Standard properties allow two months or fourteen months. GA4 360 allows 2, 14, 26, 38, or 50 months.
- Google Signals demographic retention is sixty-three days regardless of the property retention setting.
- Universal Analytics closed on July 1, 2024. Organizations without an export lost historical conversion trends, seasonal benchmarks, and campaign data within hours.
- BigQuery export is the durable fix. The daily export fee is zero, and BigQuery active storage costs $0.020 per gigabyte monthly.
Last updated: November 2026
Enterprise digital analytics operates under a new reality defined by data ephemerality and vendor-enforced storage ceilings. For nearly two decades, organizations treated Google Analytics as an immutable system of record. Universal Analytics preserved years of behavioral history across annual retail cycles and customer acquisition cohorts without direct cloud storage management.
Google Analytics 4 is the platform that ended that operating assumption. GA4 is an operational reporting interface rather than an enterprise data warehouse, and native retention ceilings purge unaggregated behavioral records after fixed windows.
Organizations that rely solely on the GA4 user interface risk silent data loss. Historical conversion funnels collapse, seasonal cohorts disappear, and retrospective attribution fails. Protecting institutional data is a governance requirement, and the durable fix is an independent lakehouse architecture fed by the native BigQuery export.
What Are the GA4 Retention and Export Limits at a Glance?
Four Google Analytics controls and two BigQuery export modes are the retention and export limits at a glance. Each control sets how long raw event telemetry survives, and the dated tracker below records the limit and the product surface that enforces it.
| Entity | Category | Status | Key Metric | Primary Source | Last Verified |
|---|---|---|---|---|---|
| GA4 standard retention | Retention window | Configurable | Two months default, fourteen months maximum | Google Analytics property settings | November 2026 |
| GA4 360 retention | Retention window | Configurable | 2, 14, 26, 38, or 50 months | GA4 360 property settings | November 2026 |
| Google Signals demographics | Demographic reporting | Fixed ceiling | Sixty-three days regardless of property setting | Google Analytics demographic reports | November 2026 |
| Universal Analytics | Historical platform | Terminated | Interface and Reporting API closed on July 1, 2024 | Google Analytics platform notice | November 2026 |
| BigQuery daily export | Batch ingestion | Active | Zero ingestion fee, 1,000,000 event daily ceiling on standard properties | Google BigQuery export settings | November 2026 |
| BigQuery streaming export | Intraday ingestion | Active | $0.05 per gigabyte, exempt from the event cap | Google BigQuery export settings | November 2026 |
Why Does Google Analytics Delete Historical Data and What Are the Real Retention Limits?
Historical data deletion in Google Analytics is an enforced retention schedule, not an outage or a defect. Google Analytics enforces strict deletion schedules that permanently purge granular behavioral records unless an enterprise deploys an independent cloud warehouse pipeline.
The default GA4 retention ceiling is two months on standard properties. Administrators can raise the ceiling to fourteen months in free tiers and fifty months in Analytics 360. Unexported historical baselines are gone permanently, because the Universal Analytics decommissioning eradicated them.
Aggregate report retention is indefinite in GA4, and the surface-level metrics in standard reports survive every window. Custom Explorations, funnel models, and user cohorts break completely beyond the configured retention window.
The consequence of purged event-level data is permanent damage to predictive artificial intelligence training, lifetime value modeling, and multi-touch attribution audits. Enterprise teams must configure the native BigQuery export pipeline to ingest raw event telemetry into partitioned lakehouse storage before expiration cycles execute. Materializing nested GA4 telemetry into dimensional models with dbt preserves complete historical data ownership, bypasses interface sampling, and powers longitudinal business intelligence.
Infrastructure economics and global privacy compliance are the two forces behind Google Analytics data deletion. Storing petabytes of raw event telemetry across millions of accounts requires substantial compute and storage resources.
Universal Analytics managed infrastructure overhead by compressing hits into pre-aggregated daily summary tables. GA4 replaces that model with an event-stream architecture where every user interaction produces nested key-value records. To optimize cloud multi-tenant margins, Google shifted the cost of long-term event storage directly to the customer.
Regulatory mandates under GDPR and CCPA also require strict data minimization. Automated deletion schedules reduce Google compliance exposure as a data processor. The same policy transfers analytical risk to enterprises that fail to configure external data warehousing.
What Are the Mechanics of GA4 Data Expiration: Two-Month versus Fourteen-Month Retention Limits?
GA4 data expiration is governed by a single property setting in Admin under Data Collection and Modification. For standard properties, Google provides two options: two months and fourteen months. Newly provisioned properties default automatically to two months. Without a manual adjustment, Google purges all granular event and user telemetry older than sixty days, and no administrative recovery path exists.
Do Standard Reports and Explorations Delete Data Differently?
The difference between standard reports and Explorations is the database layer that each view queries. Data deletion does not impact all GA4 reporting views equally:
- Standard Aggregated Reports (Indefinite Retention): Standard dashboards (Acquisition, Engagement, Monetization) query pre-aggregated database summary tables. Aggregate tables track high-level totals: sessions, active users, page counts, and standard conversion totals. Aggregate tables exclude granular user identifiers and unindexed event parameters. Google retains aggregate tables indefinitely.
- Custom Explorations (Hard Retention Boundary): The Explorations workspace (Funnel explorations, Path explorations, Free-form tables, and User lifetime reports) queries raw, unaggregated event records. When the retention limit expires, the query engine permanently drops those granular event rows. Funnels comparing current performance against the prior year return truncated visualizations and missing historical cohorts.
The divergence is the source of a false sense of safety. Teams observe stable session counts in standard reports and assume their data is intact. Granular behavioral telemetry was often wiped months earlier.
How Does the Reset User Data on New Activity Setting Work?
The Reset user data on new activity setting is the one retention toggle that changes how long a user identifier survives. Property administrators find the toggle within data retention settings:
- When Enabled: The retention timer resets whenever an identified user initiates a new session. If a user visits in month one and returns in month thirteen, their user identifier remains active for fourteen additional months. However, individual event records older than fourteen months are still deleted. The system recognizes the user profile, but past event parameters are gone.
- When Disabled: The retention clock runs strictly from the initial user interaction. Exactly fourteen months after the first visit, the user-scoped identifier expires permanently regardless of recent activity.
GA4 360 enterprise contracts offer expanded retention options of 2, 14, 26, 38, or 50 months. Fifty months is the maximum 360 window, and the ceiling remains temporary against permanent enterprise data governance requirements.
Why Does Google Signals Demographic Data Expire After Two Months?
Google Signals demographic retention is a fixed two-month (sixty-three day) limit that no property setting overrides. Beyond sixty-three days, demographic parameters disappear from reports. Google also enforces automated thresholding on reports with low user volumes to prevent identity re-identification, and thresholding hides rows from Explorations entirely.
What Happened When Universal Analytics Closed on July 1, 2024?
The Universal Analytics sunset is the July 1, 2024 termination that closed both the user interface and the Reporting API. Organizations that neglected to export historical records lost years of conversion trends, seasonal benchmarks, and campaign performance data within hours. The shutdown demonstrated that third-party interfaces cannot serve as enterprise data repositories.
Why Can Historical UA Data Not Be Imported Directly into GA4?
Direct Universal Analytics import is impossible in GA4 because the two schemas are structurally incompatible. Organizations that attempted CSV or API pipelines found that fundamental schema differences block direct ingestion:
- Hit Hierarchies vs. Event Streams: UA organized data into hits: pageviews, screenviews, transactions, and events categorized by Category, Action, Label, and Value. GA4 uses flat event records enriched with nested key-value arrays. The two schemas cannot be merged natively without distorting attribution logic.
- Session Definitions: UA closed sessions at midnight or upon campaign parameter shifts. GA4 assigns session IDs based on timestamp parameters without arbitrary midnight splits. Comparing session counts across both systems produces significant discrepancies.
- User Identification: UA tracked browser Client IDs, whereas GA4 combines pseudonymous identifiers, authenticated user IDs, and modeled signals. Forcing UA data into GA4 corrupts native algorithmic modeling.
How Should Enterprises Archive Universal Analytics: Cold Storage or Queryable Datasets?
Universal Analytics archiving is a choice between cold cloud storage and queryable BigQuery datasets. Enterprises that preserved UA data adopted one of two approaches:
- Cold Cloud Storage (GCS / AWS S3): Extracting dimension and metric summaries into compressed CSV or JSON files stored in cloud object storage. This approach satisfies compliance mandates at minimal cost but requires manual processing scripts for analysis.
- Queryable BigQuery Partitions: Loading structured historical extracts into dedicated BigQuery datasets. By defining standardized schemas, data teams built unified SQL views unioning historical UA baselines with active GA4 event tables.
Preserving longitudinal analytics requires moving telemetry into an owned cloud environment before vendor deletion policies execute.
Which Storage Layer Survives the GA4 Retention Limit?
Storage layer selection is the decision that sets retention depth, data granularity, query latency, and total operational cost. The benchmark tracker below outlines the core enterprise analytics storage tiers.
| Storage Layer | Retention Policy | Granularity | Query Latency | Storage Cost (Enterprise) | Architectural Action |
|---|---|---|---|---|---|
| GA4 Standard UI (Free Tier) | 2 months default; 14 months administrative maximum; standard reports indefinite | Pre-aggregated summary tables in standard reports; raw event-level in Explorations (subject to sampling) | Sub-second for aggregate dashboards; 5 to 30 seconds for complex Explorations | $0 direct software licensing fee; high indirect cost via permanent historical data loss | Toggle retention setting to 14 months immediately; activate native daily BigQuery export |
| GA4 360 UI (Enterprise Tier) | 2, 14, 26, 38, or 50 months user-configurable retention policy | Un-sampled exploratory cohorts up to 50 months; high-cardinality custom dimensions | 2 to 15 seconds across multi-year funnels and high-volume segment overlaps | Starts at ~$50,000 annually base subscription contract fee | Configure 50-month retention per data stream; route raw telemetry to BigQuery for modeling |
| BigQuery Active Storage (Raw Partitions) | Permanent enterprise lifecycle (configurable via table partition expiration) | Unaggregated raw event telemetry with complete nested parameter key-value pairs | 1 to 5 seconds across billions of rows using distributed columnar BigQuery slots | $0.020 per GB monthly for uncompressed active partitions | Partition by event_date; apply cluster keys on event_name and user_pseudo_id |
| BigQuery Long-Term Storage (Partitions >90 Days) | Permanent immutable storage (indefinite archival with instant query availability) | Full granular event records identical to active storage; zero schema degradation | 1 to 5 seconds; identical analytical execution performance to active tables | $0.010 per GB monthly (automatic 50% discount applied by Google Cloud Platform) | Retain raw event partitions untouched for 90 days to trigger automatic cost reduction |
| Google Cloud Storage (Coldline / Archive) | Decades of compliance retention (governed by GCS Object Lifecycle Management) | Gzipped JSON, Apache Parquet, or Avro event dumps exported from BigQuery | Minutes to hours via BigQuery external table scans or restore jobs | $0.0012 to $0.004 per GB monthly plus data retrieval egress charges | Schedule automated monthly BigQuery export jobs dumping mature partitions to Parquet |
| Flattened Dimensional Lakehouse (dbt + BI Marts) | Enterprise lifecycle policy (typically 3 to 7 years online for BI consumption) | Cleaned, deduplicated dimensional models (fct_events, dim_sessions, dim_users) | Sub-second to 2 seconds for executive dashboards and BI semantic layers | $0.020 to $0.040 per GB monthly depending on BI caching and compute slots | Deploy dbt transformation models to materialize star-schema tables for Looker and Power BI |
The native GA4 interface imposes strict retention limits and high licensing fees. Cloud lakehouses are the ownership layer, and they add low latency and predictable compute costs.
How Does the Native BigQuery Export Pipeline Work?
The native BigQuery export is the primary solution for GA4 data deletion. GA4 provides a direct export link for both standard and 360 properties and routes unaggregated event telemetry into an enterprise Google Cloud Platform (GCP) project. The pipeline is the decoupling layer between reporting and vendor-controlled retention windows.
Two ingestion pipelines are available within GA4 Admin: Daily Export and Streaming Export.
Which Export Mode Fits: Daily or Streaming Ingestion?
The two export modes are Daily Export and Streaming Export, and the difference between them is latency, cost, and completeness. The operational characteristics separate cleanly:
- Daily Export (events_YYYYMMDD): Executes a batch export of the previous day data once every twenty-four hours. Google validates completeness and reconciles late-arriving events before closing the partition. The daily export fee is zero. Tables typically land in BigQuery between 12:00 and 24:00 UTC the following day.
- Streaming Export (events_intraday_YYYYMMDD): Streams raw events into an intraday buffer table within seconds of collection. Sub-minute availability is what powers real-time monitoring and campaign optimization. The streaming export fee is $0.05 per gigabyte. Once the daily batch table finalizes, Google drops the temporary intraday table automatically.
What Are the Export Quotas and Scalability Constraints?
The standard GA4 batch export ceiling is 1,000,000 events per day. When a site exceeds that volume, the batch export halts for the calendar date, and unrecoverable data loss follows. Streaming export is exempt from the 1,000,000 event cap.
High-traffic properties on standard tiers must either upgrade to GA4 360. The alternative is event filtering in GA4 export settings to exclude low-priority interactions such as scroll events or diagnostic pings.
How Do Partition Pruning and Table Clustering Reduce Query Cost?
The GA4 export schema is a set of date-sharded tables, and an unpriced mistake is a full archive scan on every query. Querying wildcard tables without partition pruning forces BigQuery to scan the entire historical archive and consumes substantial query slots. The remedy is conversion to partitioned tables or strict date filters using table suffix parameters. Clustering tables by event_name and user_pseudo_id groups related records on disk and minimizes bytes scanned per query.
How Do Production SQL Models Remove Duplicate GA4 Events?
Deduplication is a mandatory model step because network retries, client reconnections, and streaming buffers inject duplicate records into BigQuery. Enterprise models require programmatic deduplication with window functions before reporting tables are built:
/* Production Deduplication and Partition Pruning for GA4 Raw Telemetry */
WITH raw_events_windowed AS (
SELECT
PARSE_DATE('%Y%m%d', event_date) AS event_date_parsed,
TIMESTAMP_MICROS(event_timestamp) AS event_timestamp_utc,
event_name,
user_pseudo_id,
user_id,
(SELECT value.int_value FROM UNNEST(event_params) WHERE key = 'ga_session_id') AS ga_session_id,
(SELECT value.string_value FROM UNNEST(event_params) WHERE key = 'page_location') AS page_location,
event_params,
user_properties,
/* Generate unique hash for composite event identity */
FARM_FINGERPRINT(
CONCAT(
user_pseudo_id,
CAST(event_timestamp AS STRING),
event_name,
COALESCE((SELECT value.string_value FROM UNNEST(event_params) WHERE key = 'page_location'), '')
)
) AS event_fingerprint,
ROW_NUMBER() OVER(
PARTITION BY
user_pseudo_id,
event_timestamp,
event_name
ORDER BY event_previous_timestamp DESC
) AS dedupe_rank
FROM
`your_gcp_project.analytics_123456789.events_*`
WHERE
/* Enforce partition pruning to restrict query slot consumption */
_TABLE_SUFFIX BETWEEN FORMAT_DATE('%Y%m%d', DATE_SUB(CURRENT_DATE(), INTERVAL 30 DAY))
AND FORMAT_DATE('%Y%m%d', DATE_SUB(CURRENT_DATE(), INTERVAL 1 DAY))
)
SELECT
event_date_parsed,
event_timestamp_utc,
event_name,
user_pseudo_id,
user_id,
ga_session_id,
page_location,
event_params,
user_properties,
event_fingerprint
FROM
raw_events_windowed
WHERE
dedupe_rank = 1;
The windowed ranking in this query eliminates duplicate transmissions while preserving full parameter records for legitimate user interactions.
How Does dbt Transform Raw Nested GA4 Telemetry into Dimensional Models?
dbt transformation is the layer that turns nested GA4 telemetry into dimensional star schemas. Raw GA4 tables store event_params and user_properties as repeated record arrays. Connecting BI tools directly to raw tables forces repeated runtime unnesting. The result is slow dashboard performance and inflated compute costs.
Scalar Subqueries versus Cross Join Unnest
Scalar subqueries are the safer extraction pattern on high-volume tables. Cross-join unnest syntax causes cartesian explosions: an event containing twenty parameters multiplies the underlying row count twenty times before filtering. Scalar subqueries extract parameters inline, maintain a single row per event, and reduce memory consumption during transformation:
/* models/staging/ga4/stg_ga4_events.sql */
{{
config(
materialized = 'incremental',
partition_by = {
'field': 'event_date',
'data_type': 'date',
'granularity': 'day'
},
cluster_by = ['event_name', 'user_pseudo_id', 'ga_session_id']
)
}}
WITH base_events AS (
SELECT
PARSE_DATE('%Y%m%d', event_date) AS event_date,
TIMESTAMP_MICROS(event_timestamp) AS event_timestamp,
event_name,
user_pseudo_id,
user_id,
/* Extract session identifiers safely via scalar subqueries */
(SELECT value.int_value FROM UNNEST(event_params) WHERE key = 'ga_session_id') AS ga_session_id,
(SELECT value.int_value FROM UNNEST(event_params) WHERE key = 'ga_session_number') AS ga_session_number,
/* Extract navigation parameters */
(SELECT value.string_value FROM UNNEST(event_params) WHERE key = 'page_location') AS page_location,
(SELECT value.string_value FROM UNNEST(event_params) WHERE key = 'page_title') AS page_title,
(SELECT value.string_value FROM UNNEST(event_params) WHERE key = 'page_referrer') AS page_referrer,
/* Extract engagement and conversion metrics */
(SELECT COALESCE(value.int_value, CAST(value.float_value AS INT64), CAST(value.double_value AS INT64))
FROM UNNEST(event_params) WHERE key = 'engagement_time_msec') AS engagement_time_msec,
(SELECT value.string_value FROM UNNEST(event_params) WHERE key = 'transaction_id') AS transaction_id,
(SELECT COALESCE(value.float_value, value.double_value, CAST(value.int_value AS FLOAT64))
FROM UNNEST(event_params) WHERE key = 'value') AS transaction_value,
(SELECT value.string_value FROM UNNEST(event_params) WHERE key = 'currency') AS transaction_currency,
/* Geographic and device metadata */
geo.country AS geo_country,
geo.region AS geo_region,
geo.city AS geo_city,
device.category AS device_category,
device.operating_system AS device_os,
device.web_info.browser AS device_browser,
traffic_source.source AS traffic_source,
traffic_source.medium AS traffic_medium,
traffic_source.name AS traffic_campaign
FROM
{{ source('ga4_raw', 'events_*') }}
WHERE
_TABLE_SUFFIX = FORMAT_DATE('%Y%m%d', DATE_SUB(CURRENT_DATE(), INTERVAL 1 DAY))
{% if is_incremental() %}
AND PARSE_DATE('%Y%m%d', _TABLE_SUFFIX) >= _dbt_max_partition
{% endif %}
)
SELECT
/* Composite primary key for downstream relational integrity */
FARM_FINGERPRINT(
CONCAT(user_pseudo_id, CAST(event_timestamp AS STRING), event_name)
) AS event_surrogate_key,
CONCAT(user_pseudo_id, '.', CAST(ga_session_id AS STRING)) AS session_surrogate_key,
*
FROM
base_events
Incremental materialization in BigQuery is the scalable foundation for downstream fact and dimension tables, including fct_events, dim_sessions, and dim_users.
Identity Stitching and Session Enrichment
Identity stitching is the repair of the link between anonymous sessions and authenticated users. Standard GA4 reports cannot retrospectively link anonymous sessions to a customer once that visitor authenticates on a later visit. In BigQuery, data engineers resolve the gap by applying window functions across the user session history. Partitioning by user_pseudo_id propagates authenticated user_id values backward across prior touchpoints. The result is an unbroken, multi-year customer profile.
Building the Composable Analytics Stack: Lakehouse, BI, and Reverse ETL
A composable analytics stack is the result of decoupling storage from the GA4 interface. BigQuery then functions as the persistent layer of truth. Raw event telemetry is maintained for decades independent of vendor interface policies.
- Business Intelligence Engines (Looker / Power BI / Tableau): Analysts and business leaders query structured dimensional marts instead of raw event tables. Looker semantic layers (LookML) define standardized business metrics across global teams. Power BI connects via DirectQuery or scheduled aggregations. Both modes deliver sub-second reporting over historical event datasets.
- Predictive Artificial Intelligence Pipelines: Maintaining complete event histories enables data science teams to train propensity models, churn predictions, and recommendation algorithms in BigQuery ML or Vertex AI. Restricting analysis to the native 14-month window prevents robust longitudinal training.
- Reverse ETL and Data Activation: Reverse ETL platforms (such as Census or Hightouch) sync warehouse audience cohorts directly to activation channels, including Salesforce CRM, Braze, Klaviyo, Meta Custom Audiences, and Google Ads Customer Match, bypassing GA4 interface audience caps.
e-CENS assists enterprise teams in deploying this architecture through our cloud data warehouse architecture services and customer data platform implementations, unifying web telemetry with offline enterprise systems.
Storage Economics: BigQuery Long-Term Storage vs. GA4 360
Storage economics are the clearest argument for BigQuery. Active storage pricing is $0.020 per gigabyte monthly, and Long-Term Storage pricing is $0.010 per gigabyte once partitions remain unedited for ninety days. The monthly cost of 50,000,000 events (roughly 50 GB) is approximately $1.00 in active storage. Five years of historical event records is under $40 monthly in BigQuery. The equivalent GA4 360 contract requires a $50,000+ annual subscription.
Step-by-Step Enterprise Migration Blueprint to Beat GA4 Data Purges
The migration blueprint is a five step sequence across governance, pipeline engineering, and data modeling. Deploying an independent analytics infrastructure requires a structured roadmap:
Step 1: Immediate Administrative Audit and Retention Maximization
Step 1 is the immediate administrative audit that maximises retention runway. Log into GA4 Admin and navigate to Data Collection and Modification > Data Retention. Set Event Data Retention to fourteen months (or fifty months on GA4 360) across all active data streams. Review the Reset user data on new activity toggle against your reporting policy.
Step 2: Google Cloud Platform Provisioning and IAM Security
Step 2 is Google Cloud Platform provisioning behind scoped IAM permissions. Provision a dedicated GCP project for analytics storage (such as company-analytics-prod). Enable the BigQuery API and assign BigQuery Data Editor permissions to the Google Analytics service account (analytics-processing-dev@system.gserviceaccount.com) on the target dataset.
Step 3: BigQuery Export Configuration and Streaming Activation
Step 3 is the BigQuery export link plus streaming activation. Navigate to Product Links > BigQuery Links in GA4 Admin and connect your GCP project. Enable Daily Export for complete batch ingestion and Streaming Export for real-time monitoring. For high-volume properties, apply export filters to exclude diagnostic events. Our team supports this setup through data analytics consulting services.
Step 4: Deploy dbt Transformations and Star-Schema Modeling
Step 4 is the dbt project that materializes staging and dimensional models. Connect a dbt project to your BigQuery raw dataset. Implement staging models using scalar subqueries to unnest event parameters, followed by dimensional tables for sessions, users, and transactions. Schedule automated transformations to run after daily batch completion.
Step 5: Telemetry Observability, Automated Audits, and Cost Governance
Step 5 is telemetry observability, automated audits, and cost governance. Configure test assertions to detect row volume drops, missing keys, and schema drift. Apply BigQuery daily query byte limits and billing alerts. Establish lifecycle rules to archive raw partitions older than twelve months to Google Cloud Storage Coldline buckets as compressed Parquet files. Explore our advanced analytics consulting capabilities to evaluate your deployment.
Frequently Asked Questions About Google Analytics Data Deletion
Frequently asked questions about Google Analytics data deletion are answered below, covering retention windows, Universal Analytics imports, export quotas, user identifier resets, and BigQuery storage costs.
What is the fundamental difference between standard reports and Explorations regarding GA4 data deletion?
The fundamental difference is the database layer: standard reports in Google Analytics 4 query pre-aggregated summary tables and are retained indefinitely. Custom Explorations query raw, unaggregated event records. When the configured retention limit passes (two months by default, fourteen months maximum in free properties), Google permanently deletes those event rows. Historical funnel and cohort analyses then display zero records.
Can historical Universal Analytics data be merged directly into GA4 BigQuery datasets?
Direct import is impossible in the native GA4 schema because the structures are incompatible. UA used a hit-based session model with Category, Action, Label, and Value, while GA4 uses an event-parameter model. Data teams can still preserve both datasets side by side in BigQuery. Standardized SQL views then union legacy UA metrics with GA4 event counts.
What happens if a standard GA4 property exceeds the 1,000,000 daily BigQuery export limit?
The daily batch export quota is 1,000,000 events on standard (free) GA4 properties. A site that logs more events in a calendar day loses the unexported rows permanently. Streaming export is exempt from the cap but bills $0.05 per gigabyte. High-volume properties must upgrade to GA4 360 or filter diagnostic events in export settings.
Does turning on Reset user data on new activity prevent historical event data from being deleted?
The answer is no. The Reset user data on new activity setting only extends the lifespan of the user identifier for fourteen months from the most recent visit. Event records older than the property retention limit (two or fourteen months) are still purged. Past event parameters are gone even when the user remains active.
How much does it cost to store millions of GA4 events in Google BigQuery compared to GA4 360 licensing?
The cost difference favours BigQuery. Active storage is $0.020 per gigabyte monthly and drops to $0.010 per gigabyte after ninety days under Long-Term Storage. Fifty million monthly events (about 50 GB) cost roughly $1.00 per month, and five years of history is under $40 monthly. The GA4 360 comparison is a $50,000+ annual contract.
Protect Your Analytics Telemetry from GA4 Deletion Limits
Stop losing critical behavioral data to arbitrary vendor retention windows. Partner with e-CENS to engineer a resilient, partitioned cloud lakehouse that guarantees complete data ownership and longitudinal business intelligence.
Planning the move to GA4? Enterprise GA4 migration programmes at e-CENS are a 12-week cutover covering audit, tracking design, and the migration itself.
Mostafa Daoud