This checklist is the hands-on part of a Google Analytics audit, the GA4 version of the web analytics audit: the ten checks that invalidate a GA4 report when they fail, in the order to run them.
A Google Analytics audit checks whether your GA4 property collects the right data, under the right consent conditions, with the right event and parameter structure. Start with property configuration and data streams, then verify events, campaign tagging, User-ID, key events, privacy, tag management, anomalies, cross-domain tracking, and custom definitions.
Use this checklist by hand for a one-time review or after a major release, or get a free GA4 audit built from your real traffic. To catch drift between audits, you need continuous monitoring; when a metric has already moved, you need root-cause diagnosis. The difference is covered at the end.
Start with the data that can invalidate every report
Before you review a single event, confirm three things: you are auditing the right GA4 property and data streams, access is limited to the people who need it, and you know the consent and privacy rules that apply. A careful event review is useless if it runs on the wrong property, misses a major traffic segment, or covers data that should never have been collected.
Run the ten checks in order when you validate a setup from scratch. If you are investigating a sudden change, jump to check 8, compare the affected segments, and trace the change back to the request, the dataLayer, the tag, the consent state, or the release that introduced it.
The 10 checks at a glance
| Audit area | Failure it catches | Evidence to inspect | Likely owner |
|---|---|---|---|
| 1. Property and account structure | Data lands in the wrong property, stream, time zone, or currency, or access is too broad | Account and property hierarchy, stream IDs, time zone, currency, user permissions | Analytics lead or administrator |
| 2. Events and parameters | Important events are missing, duplicated, renamed, or sent with incomplete parameters | Tracking plan, network requests, dataLayer, DebugView, parameter values | Analytics engineer or developer |
| 3. UTM and campaign tagging | Campaign traffic splits across inconsistent source, medium, or campaign values | Live campaign URLs, acquisition reports, naming convention, auto-tagging | Marketing operations |
| 4. User-ID | Logged-in journeys fragment across devices, or an ID persists after logout | Login and logout requests, user_id values, reporting identity, consent state | Product analytics and engineering |
| 5. Key events | Business-critical actions don’t fire, fire twice, or are marked incorrectly | Key event definitions, test journeys, transaction_id, value, and currency | Growth or analytics owner |
| 6. Consent and privacy | Tags fire before consent, consent signals are missing, or personal data enters requests | Consent state, tag firing order, request payloads, URLs, custom dimensions | Privacy, analytics, and engineering |
| 7. Tag management and dataLayer | Triggers, variables, or dataLayer pushes send wrong values or stop tags from firing | GTM Preview, dataLayer pushes, trigger conditions, container versions | Tag management owner |
| 8. Anomalies and data quality | A release, campaign, browser, region, or source causes a sudden change | Time series, segmented reports, release calendar, request-level comparisons | Analytics and engineering |
| 9. Cross-domain tracking | Sessions restart, your own domain shows up as a referral, or the journey breaks at checkout or login | Domain map, _gl linker parameter, unwanted referrals, ga_session_id continuity | Analytics engineer |
| 10. Custom dimensions and metrics | Definitions are unregistered, wrongly scoped, high-cardinality, or no longer populated | Custom definitions, parameter names, scope, data types, observed values | Analytics owner |
The table is a triage map, not a substitute for the checks below. When a check fails, record the affected page, event, parameter, consent state, release, and owner, so the fix can be retested.
Verify property configuration and account structure
A poorly organized account leads to data silos, inconsistent reporting, and security risks. Auditing the GA4 account hierarchy, naming conventions, and user permissions comes first because every other check depends on it.

Why it matters
If you analyze the wrong property or data stream, every conclusion that follows is wrong. This check confirms the “what” and “where” before you analyze the “how” and “why.”
How to audit your account structure
- Review the account hierarchy: Map your Account > Property > Data stream structure. Does it reflect the business? A multi-brand company usually needs one property per brand, possibly feeding a roll-up property for executive reporting.
- Check naming conventions: A mix like “Main Site,” “Test GA4,” and “Website_New” creates confusion. Use a standard such as
[Environment]-[Brand]-[Platform], for exampleProd-YourBrand-WeborDev-YourBrand-iOS. - Validate data streams: A business with a website and an app should have a web stream and an iOS or Android stream in the same property, so cross-platform journeys can be analyzed together.
- Check time zone and currency: In Admin > Property details, confirm they match how the business reports revenue. A wrong time zone shifts daily totals; a wrong currency makes every value comparison misleading.
- Audit user permissions: In Admin > Account access management and Property access management, apply least privilege (Viewer, Analyst, Editor) and remove inactive users and old agency access.
Audit event implementation and parameter naming
Events capture every interaction in GA4, from a button click to a purchase. If implementation is inconsistent or naming is chaotic, analysis breaks. This check makes sure what you think you are tracking is what is actually collected.

Why it matters
If the web team sends form_submit and the app team sends formSubmitted, you can’t analyze form submissions across platforms. A consistent event schema is what makes cross-team analysis possible.
How to audit your event implementation
- Compare against your tracking plan: Check the events GA4 collects against your tracking plan or measurement documentation. Are there undocumented events? Are critical events missing? The tracking plan is the reference every implementation is checked against.
- Enforce naming conventions: Google recommends
snake_casefor event and parameter names (add_to_cart, notaddToCartorAdd To Cart). A SaaS platform, for instance, should sendtrial_signupfrom every channel. - Validate the parameter schema: For key events, verify that every required parameter is sent with the right data type. A
purchaseevent needstransaction_id,value,currency, anditems; avideo_progressevent is useless without the video title and percentage. - Test in DebugView: In Admin > Data display > DebugView, follow the events from a test device in real time and confirm that each one fires with its parameters populated before the change reaches production.
Validate campaign tagging and UTM parameters
Without consistent UTM parameters, you can’t attribute conversions, compare channels, or calculate return on spend. This check prevents (direct) / (none) and (not set) from swallowing your acquisition reports.
Why it matters
If one person tags utm_medium=cpc and another ppc, GA4 reports two channels and your paid search data splits in half. Budget decisions made on split data are wrong.
How to audit your campaign tagging
- Write the naming convention down: Define the exact values for
utm_source(e.g.,google,linkedin),utm_medium(e.g.,cpc,social_paid,email), and the structure ofutm_campaign(e.g.,[Region]_[Product]_[Objective]). Share it with every marketing team and agency, and treat it as the reference for every link. - Check ad platform auto-tagging: Confirm that auto-tagging is on for Google Ads and that its data reaches GA4. For Meta, LinkedIn, and other platforms, make sure their dynamic URL parameters map to your UTM structure.
- Review existing campaign data: In Reports > Acquisition > Traffic acquisition, add “Session campaign” as a secondary dimension. Look for casing errors (
Facebookvs.facebook), stray spaces, and mixed medium values (cpc,paid_search,ppc). - Use a URL builder and validate live links: A shared URL builder prevents most manual errors. Monitoring the live traffic catches the rest, including links that were tagged by hand after launch. See these UTM parameter best practices.
Review User-ID for cross-device tracking
Standard GA4 tracking identifies users by browser cookies or app instance IDs, so one person on three devices looks like three users. User-ID stitches authenticated sessions together.
Why it matters
Without a working User-ID, you overcount users and undercount lifetime value. That skews conversion rates, acquisition costs, and retention.
How to audit your User-ID implementation
- Confirm ID assignment: With your developers, check that a persistent, unique, non-PII identifier is assigned at login and sent with every subsequent event in the session.
- Verify logout behavior: The User-ID must be cleared on logout. Otherwise, the next person on a shared device inherits the previous user’s identity.
- Check reporting identity: In Admin > Data display > Reporting identity, select “Blended” or “Observed.” “Device-based” ignores your User-ID data.
- Test with a debugger: Log in with a test account and confirm in DebugView or the network panel that
user_idis present and correct on every hit. - Review consent: User-ID tracking should only start after the user has given the consent your regulations require, and it should follow your consent management platform’s logic.
Assess key events and conversion completeness
GA4 calls conversions key events. This check confirms that every business-critical action, from a purchase to a sign-up, is mapped to an event, marked as a key event, and sent with the right parameters. Without it, you can’t optimize campaigns or justify budgets.
Why it matters
If purchase is missing transaction_id, or trial_signup fails on one browser, the data that connects your tracking to revenue is gone, and nothing in the standard reports says so.
How to audit your key events
- Map business goals to key events: List every critical action (demo requests, newsletter sign-ups, purchases, downloads). In Admin > Data display > Key events, confirm each one has an event marked as a key event.
- Validate ecommerce parameters: Run a test transaction and confirm in DebugView or DevTools that
purchasecarriestransaction_id,value,currency, and a completeitemsarray. - Lead generation: Submit every form and verify that
generate_leador your equivalent fires once per submission. - SaaS: Walk the full funnel and check
trial_signup,payment_method_added, andsubscription_upgrade. - Assign values: Where possible, give non-ecommerce key events a monetary value, so channel performance can be compared on value, not just volume.
- Watch them after the audit: A key event that passes today can stop firing, or lose a parameter, after the next deployment. That is the case for monitoring the live hits instead of re-running the test by hand.
Audit data collection for privacy and PII
Collecting personally identifiable information (PII) in GA4 breaks Google’s terms of service and can lead to penalties under GDPR and CCPA. Auditing for PII, checking consent, and reviewing data handling settings protects your users and your business.
Why it matters
If emails or names reach GA4 through URLs or event parameters, you can lose that data, your property can be suspended, and the legal exposure lands on the company. Data collected without valid consent can’t be used with confidence either.
How to audit your privacy compliance
- Scan for PII: Review custom dimensions, event parameters, and page URLs for personal data. Query strings are the usual leak (e.g.,
?email=user@example.com). - Validate consent: In DevTools, confirm that GA4 tags respect the consent state from your consent management platform (CMP), that Consent Mode signals are sent before any tag fires, and that tracking stops for users who opt out. Our guide to auditing Consent Mode v2 goes step by step.
- Review data retention: In Admin > Data collection and modification > Data retention, make sure the setting (2 or 14 months for standard properties) matches your privacy policy.
- Check IP handling: GA4 doesn’t log or store IP addresses, but confirm that no server-side GTM setup or custom parameter is forwarding them.
- Check user-provided data collection: If you use it, confirm that emails and phone numbers are normalized and hashed as Google requires.
Verify tag management and dataLayer structure
Your tag manager, usually Google Tag Manager, decides which tags fire and with what data. A misconfigured container, or a poorly structured dataLayer (the JavaScript object that passes information from your site to the tag manager), leads to missing events and wrong values.

Why it matters
GA4 is only as good as what it receives. A misfiring tag or an inconsistent dataLayer pollutes every report downstream, and fixing it in GA4 is impossible after the fact.
How to audit your tag manager and dataLayer
- Review container organization: Are tags, triggers, and variables grouped in folders (
GA4 Events,Paid Media,Third-Party Tools) and named consistently (GA4 Event - add_to_cart)? - Validate the dataLayer schema: In the browser console, inspect
dataLayeron key pages and interactions. Anadd_to_cartpush, for example, should always carry a structuredecommerceobject with item details. - Test firing logic: Use GTM Preview and GA4 DebugView to confirm that the right tags fire on the intended triggers and that variables read the right dataLayer values.
- Remove dead tags: Delete tags from tools you no longer use and pixels that no longer fire. A cleaner container is easier to audit and slightly lighter on the page.
Analyze traffic anomalies and data quality issues
Once the setup is validated, look at the data itself. Sudden spikes, unexplained drops, and persistent inconsistencies are often the first sign of a broken tag, an unaccounted-for traffic source, or a collection failure.
Why it matters
A traffic spike can look like a marketing win and turn out to be bots diluting your engagement metrics. A drop in app conversions after an OS update can be a tracking failure, not lost demand. Neither shows up as an error in GA4; both distort decisions.
How to audit for anomalies and quality issues
- Establish a baseline: Look at users, sessions, and key event rates over a stable period to know what normal looks like, by hour of day and day of week where volume allows.
- Cross-reference spikes and drops: Did the spike match a campaign launch? Did the drop match a deployment? Release and campaign calendars are the fastest diagnostic tool.
- Segment before you conclude: Break the change down by channel, device, country, and landing page. Events that stop in a few European countries, for instance, point to a consent banner issue rather than a site-wide break.
- Set up custom insights: In GA4, create custom insights that alert you on significant changes in key metrics, as a first safety net.
- Monitor the hits, not just the totals: GA4 alerts tell you that a number moved, not why. Monitoring the requests themselves (the event, its properties, the consent state, the release that changed them) is what turns an anomaly into a cause. More on this in our web analytics audit guide.
Validate cross-domain and cross-subdomain tracking
When a user moves from yourbrand.com to shop.yourbrand.com or a third-party checkout, a wrong configuration makes GA4 start a new session. User counts inflate, the original source is lost, and conversions are misattributed.
Why it matters
Without cross-domain tracking, the move to a new domain starts a new session, often attributed as a referral from your own site. That distorts attribution and session counts across the whole journey.
How to audit your cross-domain setup
- Map your domains: List every domain and subdomain that belongs to one user journey (e.g.,
blog.company.com,app.company.com,checkout-provider.com). This list is the input for the next two steps. - Configure domains and unwanted referrals: In Admin > Data streams > [your web stream] > Configure tag settings, add your domains under Configure your domains, and list your own and your payment providers’ domains under List unwanted referrals.
- Test session continuity: With debug mode on, navigate across domains in DebugView and check that
ga_session_idstays the same. If it changes, the configuration is broken. - Check the linker parameter: Links between your domains should carry the
_glparameter, which passes the client and session IDs. If it’s missing, cross-domain linking isn’t working. - Use User-ID where you can: For logged-in users, User-ID unifies sessions across domains and devices without relying on cookies alone.
Review custom dimensions and metrics
Custom dimensions and metrics answer the business questions standard events can’t. This check confirms they are accurate, correctly scoped, and still populated.
Why it matters
A dimension with the wrong scope (event-scoped instead of user-scoped for a customer segment, for example) produces reports that look fine and are wrong.
How to audit your custom dimensions and metrics
- Review registered definitions: In Admin > Data display > Custom definitions, compare the list with your tracking plan. Remove or document anything unused or undocumented.
- Check naming: A mix like “author,” “AuthorName,” and “author_id” creates confusion. Standardize on
snake_case(subscription_tier,customer_segment). - Validate scope and type:
customer_segmentdescribes the user, so it is user-scoped;article_categorychanges per page view, so it is event-scoped. - Watch cardinality: Dimensions with many unique values (timestamps, session IDs, user IDs) push reports into the “(other)” row. Don’t register them as custom dimensions.
- Test values in DebugView: Confirm that each custom parameter arrives with the value you expect before anyone builds a report on it.
Beyond GA4: two checks across the stack
GA4 is rarely the only destination. The same site usually feeds an ad platform, a product analytics tool, a CRM or a warehouse, and the people reading each one expect the same numbers. Two checks cover that, whatever the analytics tool.
Compare the same metric across destinations. Map where each key event goes, and note every filter or transformation on the way. Then compare event volumes, users and conversions between the tools for the same days. A gap that holds steady is a definition to document. A gap that changes after a release is a delivery failure: an event that stopped reaching one destination, or reaches it twice.
Validate the dashboards people actually use. An audit that stops at the property misses the last step. Open the reports stakeholders read, check that each chart uses the event, filter and date range it claims, and that a metric defined in two dashboards is defined the same way in both. A correct property behind a wrong chart still produces a wrong decision.
Benchmarks: reading the results
Finding issues is only half the job. You also need to know whether your baseline metrics are healthy before and after the fix.
| Metric | Typical GA4 benchmark | Action if below benchmark |
|---|---|---|
| Engagement rate | 46% to 54% | Check bounce triggers and page load speed |
| Session duration | 2 to 2.8 minutes | Review content relevance and UX flow |
| Conversion rate (eCommerce) | 1% to 4% (varies by sector) | Audit checkout event firing and funnel steps |
| Event hit rate | Consistent across sessions | Investigate tag firing gaps with DebugView |
When you compare your numbers to these benchmarks, context matters. A media site will have different engagement patterns than a B2B SaaS product. Use benchmarks as a directional signal, not a hard pass/fail threshold.
Prioritizing your findings:
- Fix anything that affects conversion tracking first. These errors directly distort ROI reporting.
- Address consent and privacy issues next. Compliance failures carry legal and financial risk.
- Resolve data quality issues (duplicates, parameter mismatches) before moving to optimization.
- Document everything you find, even issues you can’t fix immediately. Stakeholders need to understand the gap between reported and actual performance.
Communicating audit results clearly is as important as running the audit itself. Frame findings in business terms: “We’re missing conversion data from 18% of users due to a consent configuration error” lands harder than “Consent Mode V2 isn’t set up correctly.” Use GA4 anomaly detection reports to show stakeholders the before-and-after impact of your fixes.
How often should you audit GA4?
Audit GA4 at least once or twice a year, and every quarter for high-traffic or high-revenue sites. Always run one after a major website change, a platform migration, or an unexpected KPI shift. Between audits, monitor the live implementation continuously: an audit shows the setup on the day you check it, and the next release can break it again.
A one-time audit is better than nothing, but it’s not a strategy. Tracking implementations drift. Sites change. Consent regulations evolve. Your audit schedule needs to keep pace.
A three-step system for sustainable audit practice:
- Set calendar reminders for scheduled audits tied to your business planning cycle. Quarterly reviews align well with budget and strategy reviews.
- Use automated monitoring tools to catch issues between manual audits. GA4 audit tools that monitor live traffic are now the preferred approach for continuous data quality, because they surface problems in real time rather than weeks later; the data quality tools comparison separates the ones that watch the warehouse from the ones that watch the tags.
- Review KPIs quarterly against your audit findings. If a metric shifts unexpectedly, check whether a tracking change preceded it before drawing any conclusions.
Pro Tip: Always run a focused audit immediately after any significant site change, including CMS updates, checkout redesigns, or new tag deployments. These are the moments when tracking breaks most often, and catching issues early saves hours of retroactive analysis.
For a structured starting point every time, keep a copy of the GA4 audit checklist bookmarked and ready to go.
After the audit, choose the right follow-up
A manual audit tells you whether the setup was sound when you inspected it. It doesn’t tell you what changed after the next release. These three activities solve different problems:
| If you need to… | Use… | What it does |
|---|---|---|
| Establish whether a GA4 setup is configured correctly | A one-time audit | Reviews the property, implementation, consent, and reporting configuration at a point in time |
| Detect drift after releases, campaigns, or vendor changes | Continuous monitoring | Watches live collection for missing events, malformed parameters, consent failures, and unexpected changes between audits |
| Explain a change that has already happened | Root-cause diagnosis | Compares the affected requests, dataLayer, tags, consent state, segments, and recent releases to find the cause |
If you need a repeatable process, with prerequisites, benchmarks, and an audit schedule, use the Google Analytics audit template. Come back to this checklist when you need the technical map of what to inspect.
For the monitoring part, Trackingplan works where the data is produced: the hit, the dataLayer, the consent state, the GTM release. It learns your baseline from real traffic and flags missing properties, broken triggers, duplicate fires, and consent breaches as they appear, with links to the affected hits. Rethink, a digital analytics agency, gets notified “sometimes even just a couple of hours after a release,” instead of waiting a day for GA4 data (read the story). To run this checklist on your own traffic, the free GA4 audit covers events, parameters, UTMs, pixels, consent, and PII over a 9-day trial.
Use the findings from this checklist to decide which events, parameters, and consent states matter most, and when a metric moves, trace it back to the request before you change the report.
Go deeper
- Google Analytics audit tools compared: the twelve best, from one-off property audits to continuous monitoring of every event.