GA4 CSV Analysis with Tkinter and Pandas DataFrame

Tkinter interface for loading and cleaning Google Analytics CSV data with Pandas

This project uses Tkinter and Pandas to prepare a Google Analytics 4 report exported as a CSV file.

The user selects the Analytics CSV through a Tkinter file browser. The application detects the report header, creates a DataFrame, removes empty data, optionally removes query strings from page paths, creates Python-friendly column names and saves the cleaned DataFrame as another CSV file.

GA4 report
    |
    v
Download CSV
    |
    v
Tkinter file browser
    |
    v
Detect header row
    |
    v
pd.read_csv()
    |
    v
Clean DataFrame
    |
    v
Save cleaned CSV

GA4 note: older Universal Analytics tutorials used reports such as Behavior > Site Content > All Pages. This project is designed for CSV exports from the current Google Analytics reporting interface.

Show Table of Contents

Download a GA4 Pages Report
Why CSV Structure Can Vary
Detect the Header Row
Create the DataFrame
Detect the Page Dimension
Clean Empty Data
Remove Query Strings
Clean Column Names
Preview the Result
Save the Cleaned CSV
Complete GA4 CSV Cleaner
Continue with Data Analysis
FAQs

Download a Google Analytics 4 Pages Report Top ↑

In Google Analytics 4, open the Pages and screens report and set the required date range and report configuration before exporting the data.

Download the report as a CSV file. The exact columns in the downloaded file depend on the dimension, metrics and report configuration you selected.

A page report can contain columns such as:

Page path and screen class
Views
Active users
Views per active user
Average engagement time per active user
Event count
Key events
Total revenue

Do not build the Python program around one fixed list of Analytics metrics. A report can contain a different set of columns.

Why We Do Not Use a Fixed skiprows Value Top ↑

The older version of this tutorial used:

df=pd.read_csv(
    file,
    skiprows=6
)

That depended on the format of an older Analytics export.

A more reusable approach is:

Analytics CSV
     |
     v
Scan first rows
     |
     v
Find page-dimension header
     |
     v
Use that row as CSV header

This lets the application handle leading report information without assuming that the header is always on a particular physical line.

The application looks for common Pages and screens dimensions:

PAGE_DIMENSIONS=[
    'Page path and screen class',
    'Page path + query string and screen class',
    'Page title and screen class',
    'Page title and screen name'
]

The first part of the CSV file is scanned:

def detect_header_row(file_path):
    with open(
        file_path,
        'r',
        encoding='utf-8-sig',
        newline=''
    ) as file:
        reader=csv.reader(file)

        for row_number,row in enumerate(reader):
            values=[
                value.strip()
                for value in row
            ]

            if any(
                name in values
                for name in PAGE_DIMENSIONS
            ):
                return row_number

If no expected page dimension is found, the application reports that the selected file does not look like the expected GA4 page report.

Create a Pandas DataFrame from the GA4 CSV Top ↑

After detecting the header row:

header_row=detect_header_row(
    file_path
)

df=pd.read_csv(
    file_path,
    skiprows=header_row
)

The selected header row becomes the DataFrame column header.

The application preserves two DataFrames:

source_df
cleaned_df

source_df represents the imported Analytics report. cleaned_df is created when the cleaning operation runs.

Detect the Page Dimension Top ↑

Instead of assuming that the page field is called simply Page, the application detects which supported GA4 dimension is present.

def find_page_column(columns):
    for name in PAGE_DIMENSIONS:
        if name in columns:
            return name

    return None

This makes the program less dependent on one report configuration.

Remove Blank Rows and Columns Top ↑

Remove columns that contain no data:

cleaned_df=cleaned_df.dropna(
    axis=1,
    how='all'
)

Remove completely empty rows:

cleaned_df=cleaned_df.dropna(
    how='all'
)

Rows without a page dimension are also removed:

cleaned_df=cleaned_df.dropna(
    subset=[page_column]
)

The page values are stripped of surrounding spaces:

cleaned_df[page_column]=cleaned_df[
    page_column
].astype('string').str.strip()

Remove Query Strings from Page Paths Top ↑

A URL such as:

/python/list.php?utm_source=newsletter

can represent the same underlying page as:

/python/list.php

The old tutorial removed every row containing ?. That can discard valid traffic.

The revised application can instead remove only the query-string part:

cleaned_df[page_column]=cleaned_df[
    page_column
].str.replace(
    r'\?.*$',
    '',
    regex=True
)

Fragments can be removed in the same way:

.str.replace(
    r'#.*$',
    '',
    regex=True
)

Important: after removing query strings, several Analytics rows can have the same normalized page path. Do not automatically sum every GA4 metric. Metrics such as users and averages require metric-aware aggregation.

Create Python-Friendly Column Names Top ↑

The older tutorial forced the DataFrame into exactly seven names:

df.columns=[
    'Page',
    'p_view',
    'u_view',
    'avg',
    'entrance',
    'b_rate',
    'b_exit'
]

This no longer fits GA4 reports.

The revised application converts whatever columns were actually exported into lower-case underscore names.

Examples:

Views
    -> views

Active users
    -> active_users

Average engagement time per active user
    -> average_engagement_time_per_active_user

The detected page dimension is given the simpler name:

page

Preview the Source and Cleaned DataFrame Top ↑

The application displays:

detected header row;
detected page dimension;
number of rows;
number of columns;
column names;
first ten records.

For example:

Rows: 1250
Columns: 8
Page field: page

COLUMNS

page
views
active_users
views_per_active_user
average_engagement_time_per_active_user
event_count
key_events
total_revenue

Save the Cleaned Analytics DataFrame Top ↑

Use the Tkinter Save As dialog:

file_path=filedialog.asksaveasfilename(
    defaultextension='.csv',
    filetypes=[
        ('CSV file','*.csv')
    ]
)

Save the cleaned DataFrame using to_csv():

cleaned_df.to_csv(
    file_path,
    index=False
)

Complete Tkinter GA4 CSV Cleaning Application Top ↑

import csv
import os
import re
import tkinter as tk
from tkinter import filedialog
from tkinter import ttk

import pandas as pd

PAGE_DIMENSIONS=[
    'Page path and screen class',
    'Page path + query string and screen class',
    'Page title and screen class',
    'Page title and screen name'
]

MAX_HEADER_SCAN=40

source_df=None
cleaned_df=None
page_column=None

root=tk.Tk()
root.title('GA4 CSV Cleaner - plus2net')
root.geometry('900x650')
root.minsize(720,520)

root.columnconfigure(0,weight=1)
root.rowconfigure(4,weight=1)

file_var=tk.StringVar(value='No GA4 CSV file selected')
summary_var=tk.StringVar(value='Rows: 0 | Columns: 0')
status_var=tk.StringVar(value='Select a GA4 Pages and screens CSV file.')
strip_query_var=tk.BooleanVar(value=True)

def detect_header_row(file_path):
    with open(
        file_path,
        'r',
        encoding='utf-8-sig',
        newline=''
    ) as file:
        reader=csv.reader(file)

for row_number,row in enumerate(reader):
            values=[value.strip() for value in row]

if any(name in values for name in PAGE_DIMENSIONS):
                return row_number

if row_number>=MAX_HEADER_SCAN:
                break

return None

def find_page_column(columns):
    for name in PAGE_DIMENSIONS:
        if name in columns:
            return name

return None

def safe_column_name(name):
    name=str(name).strip().lower()
    name=re.sub(r'[^a-z0-9]+','_',name).strip('_')

if not name:
        name='column'

if name[0].isdigit():
        name='col_'+name

return name

def rename_columns(data,detected_page_column):
    used=set()
    names=[]

for column in data.columns:
        if column==detected_page_column:
            base='page'
        else:
            base=safe_column_name(column)

name=base
        counter=2

while name in used:
            name=f'{base}_{counter}'
            counter+=1

used.add(name)
        names.append(name)

data=data.copy()
    data.columns=names

return data

def show_dataframe(data,title,extra=''):
    output.delete('1.0',tk.END)

if data is None:
        return

columns='\n'.join(map(str,data.columns))
    preview=data.head(10).to_string(index=False)

text=(
        f'{title}\n\n'
        f'Rows: {data.shape[0]}\n'
        f'Columns: {data.shape[1]}\n'
    )

if extra:
        text+=extra+'\n'

text+=(
        '\nCOLUMNS\n\n'
        f'{columns}\n\n'
        'FIRST 10 ROWS\n\n'
        f'{preview}'
    )

output.insert(tk.END,text)

summary_var.set(
        f'Rows: {data.shape[0]} | Columns: {data.shape[1]}'
    )

def load_csv():
    global source_df,cleaned_df,page_column

file_path=filedialog.askopenfilename(
        title='Select GA4 CSV file',
        filetypes=[
            ('CSV files','*.csv'),
            ('All files','*.*')
        ]
    )

if not file_path:
        status_var.set('No CSV file selected.')
        return

try:
        header_row=detect_header_row(file_path)

if header_row is None:
            status_var.set(
                'GA4 page dimension was not found in the first '
                f'{MAX_HEADER_SCAN+1} rows.'
            )
            return

new_df=pd.read_csv(
            file_path,
            skiprows=header_row
        )

except (
        OSError,
        UnicodeDecodeError,
        pd.errors.ParserError,
        pd.errors.EmptyDataError
    ) as e:
        status_var.set(f'Unable to read CSV: {e}')
        return

detected_page_column=find_page_column(new_df.columns)

if detected_page_column is None:
        status_var.set(
            'Expected GA4 page dimension was not found.'
        )
        return

source_df=new_df
    cleaned_df=None
    page_column=detected_page_column

file_var.set(file_path)

show_dataframe(
        source_df,
        'SOURCE GA4 DATA',
        f'Header row: {header_row+1}\n'
        f'Page dimension: {page_column}'
    )

clean_button.config(state=tk.NORMAL)
    save_button.config(state=tk.DISABLED)

status_var.set(
        f'Loaded {os.path.basename(file_path)}. '
        'Review the data and click Clean Data.'
    )

def clean_data():
    global cleaned_df

if source_df is None or page_column is None:
        status_var.set('Load a GA4 CSV file first.')
        return

data=source_df.copy()

data=data.dropna(axis=1,how='all')
    data=data.dropna(how='all')
    data=data.dropna(subset=[page_column]).copy()

data[page_column]=(
        data[page_column]
        .astype('string')
        .str.strip()
    )

data=data[
        data[page_column].notna()
        & data[page_column].ne('')
    ].copy()

stripped=False

if (
        strip_query_var.get()
        and 'path' in page_column.lower()
    ):
        data[page_column]=(
            data[page_column]
            .str.replace(r'\?.*$','',regex=True)
            .str.replace(r'#.*$','',regex=True)
        )

stripped=True

data=data.reset_index(drop=True)
    data=rename_columns(data,page_column)

cleaned_df=data

extra='Page field renamed to: page'

if stripped:
        extra+='\nQuery strings and fragments removed from page paths.'

show_dataframe(
        cleaned_df,
        'CLEANED GA4 DATA',
        extra
    )

save_button.config(state=tk.NORMAL)

status_var.set(
        f'Cleaned DataFrame contains {len(cleaned_df)} row(s).'
    )

def show_source():
    if source_df is None:
        status_var.set('Load a GA4 CSV file first.')
        return

show_dataframe(
        source_df,
        'SOURCE GA4 DATA',
        f'Page dimension: {page_column}'
    )

status_var.set('Showing original imported DataFrame.')

def show_cleaned():
    if cleaned_df is None:
        status_var.set('Clean the DataFrame first.')
        return

show_dataframe(
        cleaned_df,
        'CLEANED GA4 DATA',
        'Page field: page'
    )

status_var.set('Showing cleaned DataFrame.')

def save_cleaned():
    if cleaned_df is None:
        status_var.set('Clean the DataFrame before saving.')
        return

file_path=filedialog.asksaveasfilename(
        title='Save cleaned GA4 CSV',
        defaultextension='.csv',
        filetypes=[
            ('CSV file','*.csv')
        ]
    )

if not file_path:
        status_var.set('Save cancelled.')
        return

try:
        cleaned_df.to_csv(
            file_path,
            index=False
        )
    except OSError as e:
        status_var.set(f'Unable to save CSV: {e}')
        return

status_var.set(
        f'Saved {len(cleaned_df)} row(s) to '
        f'{os.path.basename(file_path)}.'
    )

top_frame=ttk.Frame(root,padding=10)
top_frame.grid(row=0,column=0,sticky='ew')
top_frame.columnconfigure(1,weight=1)

ttk.Button(
    top_frame,
    text='Load GA4 CSV',
    command=load_csv
).grid(row=0,column=0,padx=(0,10))

ttk.Label(
    top_frame,
    textvariable=file_var,
    wraplength=720
).grid(row=0,column=1,sticky='w')

controls=ttk.Frame(root,padding=(10,5))
controls.grid(row=1,column=0,sticky='w')

ttk.Checkbutton(
    controls,
    text='Remove query strings from page paths',
    variable=strip_query_var
).grid(row=0,column=0,padx=(0,10))

clean_button=ttk.Button(
    controls,
    text='Clean Data',
    command=clean_data,
    state=tk.DISABLED
)
clean_button.grid(row=0,column=1,padx=5)

ttk.Button(
    controls,
    text='Show Source',
    command=show_source
).grid(row=0,column=2,padx=5)

ttk.Button(
    controls,
    text='Show Cleaned',
    command=show_cleaned
).grid(row=0,column=3,padx=5)

save_button=ttk.Button(
    controls,
    text='Save Clean CSV',
    command=save_cleaned,
    state=tk.DISABLED
)
save_button.grid(row=0,column=4,padx=5)

ttk.Label(
    root,
    textvariable=summary_var,
    font=('Arial',10,'bold')
).grid(row=2,column=0,sticky='w',padx=10,pady=(5,0))

ttk.Separator(
    root,
    orient='horizontal'
).grid(row=3,column=0,sticky='ew',padx=10,pady=5)

output_frame=ttk.Frame(root,padding=(10,5))
output_frame.grid(row=4,column=0,sticky='nsew')
output_frame.columnconfigure(0,weight=1)
output_frame.rowconfigure(0,weight=1)

output=tk.Text(output_frame,wrap='none')
output.grid(row=0,column=0,sticky='nsew')

y_scroll=ttk.Scrollbar(
    output_frame,
    orient='vertical',
    command=output.yview
)
y_scroll.grid(row=0,column=1,sticky='ns')

x_scroll=ttk.Scrollbar(
    output_frame,
    orient='horizontal',
    command=output.xview
)
x_scroll.grid(row=1,column=0,sticky='ew')

output.configure(
    yscrollcommand=y_scroll.set,
    xscrollcommand=x_scroll.set
)

ttk.Label(
    root,
    textvariable=status_var,
    wraplength=850
).grid(row=5,column=0,sticky='w',padx=10,pady=(5,10))

root.mainloop()

Why We Keep Source and Cleaned Data Separately Top ↑

The application stores:

source_df
cleaned_df

The original imported report remains in source_df. Cleaning creates another DataFrame.

GA4 CSV
   |
   v
source_df
   |
   +----------------+
   |                |
   v                |
clean_data()        |
   |                |
   v                |
cleaned_df          |
                    |
Show Source --------+

This makes it easy to compare the report before and after cleaning.

Why We Do Not Automatically Merge Duplicate Page Paths Top ↑

Removing query strings can turn:

/python/list.php?a=1
/python/list.php?a=2
/python/list.php?a=3

into:

/python/list.php
/python/list.php
/python/list.php

It may be tempting to immediately group these rows and sum every metric.

However, Analytics metrics do not all behave the same way. A metric such as page views can often be summed across rows, while user-based or average metrics should not automatically be added together.

This page therefore prepares the DataFrame but leaves aggregation to a later analysis step where the correct metric-specific calculation can be chosen.

Analyze the Cleaned GA4 Data Top ↑

After saving the cleaned CSV, continue with the practical analysis project:

Pandas GroupBy and Pivot Analysis

You can also choose specific DataFrame columns:

Select DataFrame Columns

Or search the DataFrame through a Tkinter interface:

Search DataFrame Records

Frequently Asked Questions Top ↑

Q1: Which Google Analytics report is this tutorial designed for?

It is designed primarily for CSV exports containing a GA4 page dimension such as Page path and screen class or Page path + query string and screen class.

Q2: Why does the program detect the CSV header instead of using skiprows=6?

A fixed skip value depends on one export format. Detecting a known GA4 page dimension makes the import less dependent on a specific number of leading rows.

Q3: Why not delete every page containing a question mark?

A question mark normally introduces a query string. Removing the complete row can discard useful Analytics data, so the revised example removes only the query-string portion of a page path.

Q4: Why are the Analytics column names changed?

Spaces and punctuation are converted to lower-case underscore names so the columns are easier to reference in later Python and Pandas operations.

Q5: Why is the page dimension renamed to page?

GA4 provides several possible page dimensions. Renaming the detected dimension to a consistent page field makes later processing simpler.

Q6: Does removing query strings automatically combine duplicate page rows?

No. The rows remain separate because different GA4 metrics require different aggregation rules.

Q7: Does cleaning modify the downloaded GA4 file?

No. The downloaded report remains unchanged. A separate cleaned DataFrame is created and can be saved as a new CSV file.

Pandas Data Analysis Select DataFrame Columns Search DataFrame

Tkinter Projects Tkinter Pandas Projects

Python Tkinter Pandas read_csv() Data Cleaning to_csv() Python Tutorials

Subhendu Mohapatra

Author & Instructor at plus2net

I write and maintain practical tutorials on Python, PHP, SQL, JavaScript, HTML, jQuery, and web development at plus2net. The tutorials focus on clear explanations, working examples, and code that readers can test and adapt while learning.

About the author Watch on YouTube

Connect: