How WhatPulse Measures Keystrokes, Clicks, and BandwidthWhatPulse is a lightweight desktop tool that collects and reports usage statistics such as keystrokes, mouse clicks, and network bandwidth. This article explains how WhatPulse captures each type of data, what it records exactly, how it processes and stores that information, privacy considerations, and common use cases and limitations.
What WhatPulse Measures (Overview)
WhatPulse focuses on three primary activity types:
- Keystrokes — counts of keys pressed across the system.
- Clicks — mouse button clicks, including left/right and sometimes wheel clicks.
- Bandwidth — network data sent and received per application and per network interface.
It can also collect additional stats such as uptime, active application time, and per-application usage breakdowns when supported by the operating system.
How Keystrokes Are Counted
WhatPulse does not capture the content of what you type; it records counts and basic metadata to measure typing activity.
How it works:
- On Windows, macOS, and Linux, WhatPulse uses platform-specific APIs to monitor keyboard events. These are low-level keyboard hooks or event listeners that notify the application whenever a key is pressed.
- Each keypress increments a counter tied to the active session and optionally to a per-application tally.
- Modifier behavior: pressing and holding modifiers (Ctrl, Alt, Shift) or repeating keys typically increments counts according to actual key events, not inferred text.
- It distinguishes between physical key events and text composition (for IMEs) when possible, but IME behavior can vary by OS and locale.
What is stored:
- Total keypress count (per day, per session, lifetime).
- Per-application keypress counts (when the OS allows foreground application attribution).
- No key contents, no screenshots, no clipboard capture.
How Mouse Clicks Are Counted
WhatPulse records mouse button events to quantify clicking activity.
Mechanics:
- It hooks into OS-level mouse event APIs to detect button presses (left, right, middle, extra buttons).
- Each detected press increments a click counter; double-clicks count as two separate clicks because they are two events.
- Wheel scroll events are sometimes tracked separately depending on settings and platform support.
What is stored:
- Total clicks (per day, per session, lifetime).
- Per-button breakdowns and per-application attribution where possible.
- No cursor tracking or positional heatmaps by default (unless a specific feature or plugin adds that).
How Bandwidth Is Measured
WhatPulse tracks network usage to show how much data you send and receive.
Methods:
- It monitors network interfaces to read counters exposed by the OS (bytes sent/received per interface).
- On supported systems, it can attribute bandwidth to specific processes or applications by correlating socket/process statistics from the OS.
- For accurate per-application stats, WhatPulse queries system APIs that report per-process network usage (e.g., Windows Performance Counters, procfs on Linux). Granularity and permissions required differ by OS.
What is stored:
- Total bytes uploaded/downloaded per interface and overall.
- Per-application bandwidth usage when available.
- Historical aggregates (daily, monthly) and lifetime totals.
Data Processing, Aggregation, and Syncing
Local aggregation:
- WhatPulse keeps local counters that aggregate keystrokes, clicks, and bandwidth over configurable intervals.
- It maintains per-day and lifetime totals and can present per-application breakdowns locally.
Server syncing:
- When you choose to upload stats, WhatPulse sends aggregated counts (not raw event logs) to its servers for leaderboard and backup features.
- Uploads are periodic and typically contain totals for the upload period rather than individual event records.
Privacy/design choices:
- WhatPulse emphasizes that it does not record the content of keystrokes. Uploaded data is statistical rather than textual.
- Per-application attribution may expose which apps are used, so users should be aware before enabling upload of application-level stats.
Privacy and Security Considerations
- WhatPulse records counts, not content. It is designed to avoid capturing the actual text typed.
- Per-application data can reveal usage patterns; treat that as identifying behavior.
- On some systems, measuring per-process bandwidth or foreground application attribution may require elevated permissions — granting these increases the scope of data accessible to the app.
- Users concerned about privacy can disable per-application tracking or uploading; local-only use reduces exposure.
- Keep WhatPulse updated to benefit from security and privacy fixes.
Common Use Cases
- Productivity tracking: monitor typing and clicking to estimate activity and focus patterns.
- Gamers: track keystrokes and clicks for personal metrics or comparison on leaderboards.
- Network monitoring: identify heavy bandwidth usage by application or interface.
- Device comparisons: compare input and network activity across machines.
Limitations and Edge Cases
- IMEs and specialized keyboards may alter how keystrokes are counted.
- Virtual machines and remote-desktop sessions may under- or over-report events depending on how input is passed through.
- Per-application bandwidth attribution is OS-dependent and may be imprecise for short-lived processes or encrypted tunnels.
- Double-counting can occur if multiple monitoring tools or drivers interact with the same input events.
Practical Tips
- Enable only the features you need (disable app-level attribution if privacy is a concern).
- Run WhatPulse with necessary permissions for per-app bandwidth only when you trust the environment.
- Compare daily and weekly trends rather than single-day spikes to understand behavior.
Conclusion
WhatPulse measures keystrokes, clicks, and bandwidth by listening to OS-level input and network APIs, aggregating counts locally, and optionally uploading summary statistics. It focuses on counts and attribution rather than content capture, but per-application and per-interface data can still reveal meaningful usage patterns, so enable features with awareness of privacy trade-offs.
Leave a Reply