Firebase / GA4 export
If your game uses Firebase Analytics (or Google Analytics 4) with the BigQuery export linked, you already have everything Asemic needs. Asemic reads the export directly: no flattening pipeline to build, no scheduled views to maintain, and the connection stays read-only. For many studios this means the “connect your warehouse” step is already done before they arrive.
What the export looks like
Linking Firebase or GA4 to BigQuery creates a dataset named analytics_<propertyId> containing one table per day (events_20260718, events_20260719, …), plus an events_intraday_ table for the current, not-yet-finalized day. Days finalize roughly 24 to 72 hours after they close. Useful fields like level, score, or purchase value live inside a nested event_params structure rather than as flat columns.
Raw, that shape is awkward to query. Asemic handles both parts of the awkwardness for you: the daily shards behave as a single events source, and the nested parameters surface as ordinary typed columns.
Connect
Follow the standard warehouse connection with BigQuery. The connection needs read access to your analytics_<propertyId> dataset and write access to the dataset you choose as “Data model schema”. A service account with those two grants is enough; Asemic never needs to write to the export itself.
Once connected, the dataset listing shows the export as a single events_* entry instead of thousands of daily tables.
Import your events
Run event setup as usual and pick your analytics_<propertyId> dataset. When the dataset’s tables collapse to a single events_* entry, the wizard shows “Firebase / GA4 export detected” with an “Import GA4 events” button.
The import reads the last 7 days of your export and builds the model from what your game actually sends, not from a template:
- One event per event type seen. Every
event_namewith rows in those 7 days becomes an event, split out of the one big export table byevent_name. - Parameters as typed columns. Each
event_paramskey the event carries becomes a column, typed by the values the data populates. A parameter that arrives as an integer on some rows and a double on others is read from both, so an SDK change does not silently drop values. Firebase bookkeeping parameters (firebase_screen_idand similar) are left out. - User properties. Your
user_propertiesbecomeuser_prop_<key>columns. Firebase’s own properties are skipped. - Export-wide fields. Every event also carries the fields GA4 writes on every row:
platform,user_id,event_value_in_usd, and thegeo.*,device.*,app_info.*, andtraffic_source.*fields as flat columns (geo.countrybecomesgeo_country). Country, platform, device category and operating system, app version, and acquisition source are set up as registration properties, so you can segment cohorts by them from day one. - Identity and time.
user_pseudo_idis the user id. The event time is the export’s microsecondevent_timestamp, so dates need no preparation on your side. - Install time.
user_first_touch_timestampcarries the “Install time” tag, so a player’s registration date is their real install date, even if they installed before your export begins (see Who counts as a new user). - Roles.
first_openmaps to Registration (first_visitwhen there is nofirst_open),in_app_purchaseorpurchaseto Payment withvalueas the amount, and Firebase’s housekeeping events (app_remove,app_update,os_update,app_exception,notification_receive, and similar) to System, so they do not count a player as active. Everything else is a User event.
When it finishes, the wizard says how many event types it built: “Built from your export: {n} event types seen in the last 7 days, with the parameters they actually carry.” Review the list, remove what you do not need, then “Generate”, build out the model, publish, and backfill.
A few things the import cannot know, and you should check:
- Rare events. An event that did not fire in the last 7 days is not built. Add it by hand.
- Your own server-side events land as User. If one does not mean a player was active, tag it System.
- Ad revenue. An
ad_impressionevent with avalueis imported as an ordinary event, not as revenue. Revenue metrics count payments only until you model ad revenue yourself.
If the export cannot be read (a permission problem, or no data in the last 7 days), the wizard falls back to Google’s standard GA4 game events and warns that “They may not match what your game sends”. Fix the cause and run the import again rather than building on the fallback.
The single-table layout (“One big events table”) cannot read a GA4 export’s microsecond timestamps or its nested parameters. If you pick a GA4 export there, the wizard says so and offers “Use GA4 import”.
Who counts as a new user
Most players never send first_open inside the export: they installed before the export was linked, or the event was lost. Asemic therefore registers a player on the first day any user-activity event sees them, with first_open as the preferred registration row when it exists. DAU and revenue count every active player, and nobody disappears because one event was never sent.
With the “Install time” tag on user_first_touch_timestamp, the registration date is the player’s real install date. A player who installed before your data begins is placed in their true install cohort, and installs only count players who installed while your data was being collected.
Models built with the import before 28 October 2026 do not have the tag. To add it, tag user_first_touch_timestamp as “Install time” (as a microsecond Unix timestamp) or re-run the import, then publish and rebuild. Installs and early-cohort numbers change after the rebuild.
Why direct support matters: query cost
BigQuery only skips irrelevant daily shards when a query filters on the shard suffix itself. The common workaround for tools without native support, a view over events_*, silently loses that: every chart scans the entire history of the export on every load. With two years of events that is a real bill, on every query.
Asemic compiles shard pruning into the query: a chart over a date range reads only that range’s shards. On Google’s public Flood-It! export, a three-day read scanned 2.4 MB with suffix pruning against 139 MB with a date filter alone, and the gap grows with every day of history. This is what makes the export usable directly, with read-only credentials, at a predictable cost.
Time zones and shard boundaries
A GA4 daily shard holds one day in your property’s time zone, while Asemic dates events in UTC. For any property not on UTC, some of a UTC day’s events sit in the neighbouring shard. Asemic reads one extra shard on each side of every range and lets the event timestamp decide which rows count, so boundary days are complete. The cost is two extra daily shards per read.
Before 30 October 2026, event reads did not take that margin. For properties west of UTC the first day of each read came up short, and east of UTC the last day did; values built one day at a time, such as lifetime revenue, were short on every day. Active users were not affected. If your property is not on UTC and your model was built before that date, rebuild it once to correct stored values; the numbers move up to the right values.
Streaming exports (intraday)
GA4 can export daily tables (events_YYYYMMDD), streaming tables (events_intraday_YYYYMMDD), or both. Asemic handles each case:
- Daily export. Asemic reads the finalized daily tables. A day appears once Google finalizes it.
- Streaming-only export. Some properties only stream, for example because they are over GA4’s daily-export limit. The import detects this, says “Your export is streaming-only (events_intraday_* tables), so Asemic will read those”, and the model and backfills read the streaming tables.
- Both. For each day Asemic reads the daily table when it exists and the streaming table otherwise, so a day whose daily export failed still has data.
Analysis-ready events copy
The export’s nested layout makes every query unpack event_params row by row. Asemic can keep an analysis-ready copy of your recent events in your data model dataset: one table, partitioned by day and clustered by event, with event parameters and user properties unpacked into their own columns. Model builds, event charts, and funnels read the copy instead of the export for the days it holds, and scan a fraction of the data. Your team can query the copy directly too.
To turn it on, open the Data Model, choose “Model settings…” from the ⋮ menu, and switch on your export under “Analysis-ready events copy”. Set “Days kept” (default 60), publish, then recompute those days from the Materialization dialog.
- Late events. A day that gains a few late rows (up to 100 rows or 0.1%) is still read from the copy. Days that can still change are read from the export until they settle.
- Streaming-only exports are copied from the streaming tables.
- Cost. The copy costs storage for the days kept, in your BigQuery project. Days older than that are read from the export as before.
When raw days expire
If the export’s oldest daily tables are deleted (a dataset or table expiration, the BigQuery sandbox’s 60-day limit, a manual cleanup), Asemic keeps any day it has already built whose raw events are gone, builds the rest, and lists the kept days in the backfill’s warnings. Your history in Asemic outlives the export’s retention.
Honest limitations of the export
These are properties of the Firebase/GA4 export itself, worth knowing regardless of tooling:
- Identity resets.
user_pseudo_idis a device-scoped id; it resets on reinstall. If your game has accounts, setuser_idin the SDK and retention across reinstalls becomes measurable. - Attribution is first-touch. The export carries a user-level
traffic_source(the first attributed source), not full MMP-grade attribution. Good enough to segment cohorts by acquisition source; not a replacement for your MMP. - Ad revenue needs linking. In-app purchase revenue is in the export by default; ad revenue appears only if you link AdMob (or import ad revenue events yourself).