Respectlytics Respect lytics
Menu

Mobile Banking Analytics Without User IDs

A technical guide for implementing session-based analytics in financial apps while navigating PCI DSS v4.0, GDPR, LGPD, and PDPA requirements.

12 min read

Mobile banking apps face unique analytics challenges. Traditional analytics platforms collect persistent user IDs, device fingerprints, and IP addresses, data that creates liability under PCI DSS, GDPR, LGPD, and PDPA. This guide explores how session-based analytics with data minimization can provide product insights while avoiding the accumulation of sensitive identifiers.

Why Banking Analytics Is Different

Mobile banking apps operate at the intersection of financial services regulation, payment card industry requirements, and data protection law. While an e-commerce app might only consider GDPR for analytics, a banking app potentially faces:

  • • PCI DSS for any cardholder data environment
  • • GDPR for EU user data processing
  • • LGPD for Brazilian user data
  • • PDPA for Singapore and Southeast Asia
  • • Central bank regulations (BCB in Brazil, MAS in Singapore)

Each framework has its own requirements for consent, data minimization, cross-border transfers, and breach notification. Traditional analytics that collect device IDs, build user profiles, and store data indefinitely create complexity across all of them.

PCI DSS v4.0: Script Management Requirements

PCI DSS v4.0 introduced significant new requirements for client-side scripts on payment pages. While often discussed in web contexts, these requirements directly impact mobile banking apps that use WebViews for payment flows, a common pattern for 3-D Secure verification, bill payments, and credit card applications.

Requirement 6.4.3: Script Inventory and Authorization

Financial institutions must maintain an inventory of all scripts executed on payment pages, including:

  • • Authorization: Evidence each script is explicitly approved
  • • Justification: Business necessity for why the script is required
  • • Integrity checks: Verification the script hasn't been tampered with

Requirement 11.6.1: Tamper Detection

Organizations must implement mechanisms to detect and alert on unauthorized modifications to payment page content. Analytics SDKs that dynamically inject scripts, attach event listeners across the DOM, or perform "session replay" create significant noise in tamper detection systems.

Why This Matters for Analytics:

Traditional analytics SDKs are difficult to justify under PCI DSS v4.0 scrutiny:

  • Marketing analytics on a payment page is hard to justify as "necessary"
  • Tag managers that chain-load additional scripts complicate inventory management
  • Session replay that captures screen content may inadvertently record card data

Global Privacy Regulations

Beyond PCI DSS, banking apps must navigate regional privacy frameworks. Each emphasizes data minimization and purpose limitation, principles that conflict with traditional "collect everything" analytics.

GDPR (European Union)

GDPR Article 5(1)(c) requires that personal data be "adequate, relevant and limited to what is necessary" (the data minimization principle). The ePrivacy Directive adds requirements for device storage access.

Analytics implication: Persistent device IDs and cross-session tracking require explicit consent. Data minimization is architecturally expected.

LGPD (Brazil)

Brazil's LGPD mirrors GDPR's data minimization requirements. Additionally, Central Bank Resolution CMN 4.893 governs cybersecurity for financial institutions, including cloud computing and third-party risk management.

Analytics implication: Cross-border data transfers require adequacy agreements. Analytics vendors must be assessed for security posture.

PDPA (Singapore)

Singapore's PDPA includes a Retention Limitation Obligation: organizations must stop retaining personal data when the purpose is served. MAS Technology Risk Management (TRM) Guidelines hold financial institutions responsible for third-party SDK security.

Analytics implication: Persistent user IDs stored indefinitely may violate retention requirements. SDK vetting is a regulatory expectation.

Risks of Traditional Analytics in Banking

Traditional analytics architectures create specific vulnerabilities for financial applications:

Supply Chain Risk: The "Black Box" SDK Problem

Third-party analytics SDKs execute code within your app's trusted memory space with the same privileges as your banking code. Notable incidents include:

  • • E-skimming attacks: Compromised scripts inject code to capture payment credentials before encryption
  • • Session replay leaks: Tools recording user interactions inadvertently capture sensitive screens
  • • Permissions creep: SDKs requesting location, clipboard, or device sensors unnecessary for analytics

Risk Profile: Analytics Data Types

Data Type Risk Level Breach Impact
Persistent User ID Critical Full behavioral reconstruction across sessions
Device ID (IDFA/GAID) High Cross-app tracking, financial + personal behavior linkage
IP Address (stored) Medium Location identification, ISP records linkage
Session ID (rotated) Low Fragmented, isolated events; no profile reconstruction

Session-Based Analytics Architecture

Respectlytics helps developers avoid collecting personal data in the first place. Our motto is Return of Avoidance (ROA): the best way to handle sensitive data is to never collect it.

Core Architecture Principles

  • ✓ RAM-only identifiers: Session IDs stored in device memory only, never persisted to disk. App restart = new session.
  • ✓ Automatic rotation: Sessions rotate every 2 hours, preventing behavioral linkage across extended periods.
  • ✓ Server-side hashing with daily salt: Session IDs are hashed with a salt built from the app and the date, so the stored value changes every day and no stored field ties one day's sessions to another's.
  • ✓ Transient IP processing: IP addresses used for country lookup then immediately discarded, never stored in analytics.

Strict 5-Field Storage Model

Only these fields are stored, and the API architecturally rejects any extra data:

{
  "event_name": "transfer_initiated",    // What happened
  "session_id": "[hashed_rotating_id]",  // RAM-only, daily salt
  "timestamp":  "2026-01-16T10:30:00Z",   // When it occurred
  "platform":   "ios",                      // iOS, Android, Web
  "country":    "US"                        // From transient IP lookup
}

What You Can Measure

Session-based analytics provide meaningful product insights without requiring persistent user identification:

Conversion Analysis

  • • Session completion rates
  • • Onboarding funnel performance
  • • Feature-to-conversion correlation

Drop-off Detection

  • • Identify abandonment points
  • • Payment flow friction
  • • Registration bottlenecks

Feature Adoption

  • • Which features drive engagement
  • • Usage patterns by platform
  • • Geographic feature preferences

Technical Performance

  • • Error rates by platform
  • • Flow completion times
  • • Version adoption tracking

Implementation Guide

1. Design Privacy-Safe Event Names

Event names should be descriptive enough to provide insight without custom properties that might contain financial data:

// ✓ Good: Descriptive event names
"login_successful"
"transfer_initiated"
"balance_viewed"
"card_activated"
"biometric_enabled"
"payment_completed"

// ✗ Blocked: Custom properties with financial data
"transaction" + {amount: 150.00}      // API rejects
"user" + {account_id: "12345"}      // API rejects

2. SDK Integration

Swift (iOS Banking App)
import RespectlyticsSwift

// Configure at app launch
Respectlytics.configure(apiKey: "your-api-key")

// Track banking events
Respectlytics.track("login_successful")
Respectlytics.track("balance_viewed")
Respectlytics.track("transfer_initiated")
Respectlytics.track("payment_completed")
Kotlin (Android Banking App)
import io.github.respectlytics.Configuration
import io.github.respectlytics.Respectlytics

// Configure in your Application class
Respectlytics.configure(Configuration(apiKey = "your-api-key"))

// Track banking events
Respectlytics.track("login_successful")
Respectlytics.track("account_opened")
Respectlytics.track("card_activated")

3. Payment Flow Considerations

For PCI DSS considerations, you may want to limit analytics during sensitive payment flows:

// Track entry to payment flow
Respectlytics.track("payment_flow_started")

// ... sensitive card entry happens in WebView ...
// No tracking during card data entry

// Track completion after returning from payment
Respectlytics.track("payment_completed")
// or
Respectlytics.track("payment_failed")

Trade-offs and Limitations

Session-based analytics require accepting specific trade-offs. This architecture is designed for product teams who prioritize data minimization over cross-session user profiling:

What You Can't Track:

  • ✗ Cross-session user identification: Each session is independent
  • ✗ Multi-session retention metrics: Day 7, Day 30 retention requiring persistent IDs
  • ✗ Individual user lifetime value: No cross-session user profiles
  • ✗ Multi-touch attribution: Can't link ad click to transaction days later

What You Gain:

  • ✓ Reduced breach liability: Fragmented data has limited value to attackers
  • ✓ Simpler compliance documentation: Less data means fewer regulatory touchpoints
  • ✓ Transparent data practices: Clear about what is and isn't collected
  • ✓ Defensible architecture: Data minimization by design, not policy

Important: We Are Not Lawyers

Respectlytics provides a technical solution focused on data minimization. We do not provide legal advice. We do not claim our product satisfies any specific regulatory requirement. Our system is transparent about what data is collected, defensible because we minimize data by design, and clear about why each field exists. Consult your legal team to determine the requirements that apply to your situation.

Legal Disclaimer

This article provides educational information about banking regulations and analytics architecture. It does not constitute legal advice. Financial privacy regulations vary by jurisdiction, change over time, and depend on your specific app functionality. PCI DSS requirements are enforced by card brands and may have additional implementation guidance. Consult your legal team and Qualified Security Assessor (QSA) to determine the requirements that apply to your situation.

Related Resources

Try it on your own app

14-day free trial, no credit card. Unlimited apps on every plan.