Import your historical data
Import historical game analytics from GameAnalytics, PlayFab, Firebase, Unity Analytics, or any CSV into PlayGenus, so churn and LTV models train on your real history.
If your game is already live, you have history worth keeping. Historical import takes an export from your current analytics platform, maps its events onto your PlayGenus tracking plan, and loads them in — so your models train on your real players instead of starting from an empty dataset.
Import is self-serve: you drive it from Historical Imports in the sidebar. We review the event mapping with you before anything is ingested.
Before you start
You need a game that's already been onboarded and has an approved tracking plan. Import maps your old events onto that plan, so the plan has to exist first. If you're not there yet, see How onboarding works.
How much history to bring
Bring as much as you have. Model quality is gated by the total span of your history, not by any single file — and the difference between 30 days and a year is substantial.
| History | What it unlocks |
|---|---|
| Under 30 days | Descriptive dashboards only — retention, funnels, and ARPDAU work. Predictive models need roughly 30 days before they can train at all. |
| 30–89 days | Churn and survival models can train. LTV and revenue forecasts may still be unreliable. |
| 90–179 days | Solid coverage for churn, LTV, and survival. Forecasts keep sharpening. |
| 180–364 days | Strong accuracy across all models. |
| 365+ days | Full accuracy, including seasonal and year-over-year patterns. |
90 days is a sensible minimum. Six months or more is better.
Step 1 — Export from your current platform
Pick your source format in Historical Imports → New import. Each option shows the same recipe reproduced below.
GameAnalytics
- GameAnalytics dashboard → Tools → Data Export.
- Pick the date range and event types you want.
- Download the JSON/NDJSON file.
PlayFab
- PlayFab Game Manager → Data → Event History.
- Set the range and click Export.
- Download the JSON/NDJSON file when the export email arrives.
Firebase Analytics (BigQuery export)
Firebase event tables live in BigQuery, and the fields that matter —
event_params and user_properties — are nested and repeated. BigQuery cannot
export nested or repeated columns to CSV, so export as JSON:
EXPORT DATA OPTIONS(
uri='gs://your-bucket/firebase-*.json',
format='JSON'
) AS
SELECT * FROM `<project>.analytics_*.events_*`
WHERE _TABLE_SUFFIX BETWEEN 'YYYYMMDD' AND 'YYYYMMDD'This produces newline-delimited JSON. Download it from your GCS bucket and upload it. (If you have a pre-flattened CSV export, that works too.)
Unity Analytics / UGS
- Unity Dashboard → Analytics → Data Export.
- Set the date range and request the export.
- Download the TSV file.
Other / Custom CSV
Any CSV works, as long as it has three columns:
| Column | Notes |
|---|---|
player_id | Your stable identifier for the player. |
event_name | The name of the event. |
timestamp | ISO 8601, Unix seconds, or Unix milliseconds — we detect which. |
Every other column is treated as an event property and mapped automatically.
Step 2 — Upload
Drag and drop, or browse. Uploads go straight from your browser to storage, so large files don't stall on an intermediate hop, and you get live progress.
- Accepted formats: CSV, JSON, NDJSON, TSV.
- Maximum size: 1 GB per file.
- Your first import for a game is a single file. Once its mapping is reviewed and approved, later imports accept many files at once and reuse the saved mapping automatically.
That single-file rule isn't arbitrary. The first import is what establishes your mapping; running several files through mapping in parallel with nothing to anchor them would produce inconsistent results.
Don't close the tab mid-upload — you'll be warned if you try. Once the upload finishes, processing happens server-side and you can leave.
Step 3 — We parse and propose a mapping
Processing usually takes 5–30 seconds. We read the file, work out the schema of each event type from a sample of its rows, and propose a mapping from your source events onto your tracking plan.
Where your game already has a saved mapping from a previous import, those entries are reused as-is, and only genuinely new event types are sent to the mapping model. Nothing about your event data trains a shared model.
Step 4 — Review the mapping
This is the part that needs you. Open the import and you'll get a table: one row per source event type, mapped to a target event in your tracking plan.
- Include or exclude each event. Not everything deserves to come across.
- Change the target where our proposal is wrong.
- Event families group related events so you can map or exclude a whole set at once.
- Noise — events we think aren't worth ingesting — collapse into a de-emphasised group at the bottom. Overrule it whenever you disagree.
- Properties map either as a copy (a source column to a target property) or a constant (a fixed value stamped onto every event — useful when the source file implies something it never actually records, like a platform).
- Comments let you leave a note for us on any row.
If your game has a saved mapping, a banner breaks the rows down into what came from the saved mapping, what's new, and what you've changed — and new AI-proposed rows are pinned to the top, because those are the ones worth your attention.
Edits are not auto-saved. Use Save, or submit — which saves for you.
Step 5 — Submit, and we confirm
When you're happy, click Submit for admin review. This does not start the import.
A PlayGenus engineer reviews the mapping with you and confirms it. That's the step that begins ingestion. It's deliberate: a bad mapping quietly corrupts every model downstream of it, and the cost of catching that afterwards is far higher than the cost of a second pair of eyes now. Your mapping stays editable while it's waiting.
This is also how we get better over time — a confirmed mapping is saved for your game, so your next import mostly maps itself.
Step 6 — Backfill and retrain
Once confirmed, we translate the file through the mapping, load it, and trigger a retrain of the models that depend on it — churn, LTV, survival, and the DAU, revenue, and session forecasts.
Charts and reports appear as soon as the import finishes. Predictions follow once retraining completes.
Importing the rest of your history
After your first import is approved, the game has a saved mapping. From then on:
- The source format collapses to a one-liner — Source format: X — same as your last import — with a Change link if you've switched platforms.
- Reuse saved mapping is on by default.
- You can upload many files at once and watch them move through a per-file queue. Any file that fails can be retried on its own without disturbing the others.
Troubleshooting
A file failed. Retry it from the queue. Failures before the review stage are retryable directly; if a file fails during ingestion, tell us and we'll re-run it.
I picked the wrong source format. Delete the import and start again — deleting an import you haven't ingested costs nothing.
Delete removes an import from your list but leaves any already-ingested data in place. If you need data actually removed, email us.
My export is bigger than 1 GB. Split it by date range and upload the parts. After the first file is approved, the rest can go up together.
Questions
Email support@playgenus.com. If you're mid-import and something looks wrong in the mapping table, leave a comment on the row — it reaches us with the context attached.