Last updated: March 16, 2026

Modern Android keyboards collect and transmit typing data to their developers, Google’s Gboard and Samsung Keyboard are no exceptions. This guide explains how typing data flows to these companies, what information gets collected, and practical steps developers and power users can take to prevent it.

Prerequisites

Before you begin, make sure you have the following ready:

Step 1 - How Android Keyboards Transmit Data

Android keyboards operate with extensive system permissions. When you install Gboard or Samsung Keyboard, these apps request permission to read what you type, which fields you’re filling, and sometimes even what you’re about to type before you finish. This capability, called “predictive text” or “personalized suggestions,” requires sending data to remote servers.

Google’s Gboard collects typing patterns to improve Google Search suggestions, autocomplete, and voice recognition. Samsung Keyboard similarly collects data to enhance predictive text and Samsung’s own services. Both keyboards transmit data over HTTPS, often including:

For developers building privacy-conscious applications, understanding this data flow is essential. Users increasingly demand control over their typing data, and offering keyboard-aware privacy options can differentiate your app.

Step 2 - Disable Data Collection in Gboard

Google’s Gboard provides several settings to limit data collection, though some remain tied to your Google account.

Turn Off Personalized Suggestions

Open Gboard settings on your device and navigate to Settings > Gboard > Privacy. Disable “Personalized suggestions” and “Improve keyboard and input”. This prevents Gboard from sending typing data to Google for personalization.

For developers automating device configuration via ADB
adb shell settings put secure gboard_personalization_enabled 0
adb shell settings put secure gboard_usage_stats_enabled 0

Disable Voice Typing Data Collection

Voice typing through Gboard sends voice recordings to Google servers. To disable this:

  1. Go to Settings > Google > Voice
  2. Turn off “Voice Match” or restrict voice data storage
  3. In Gboard settings, disable “Voice typing” shortcuts

Block Gboard Network Access

For maximum privacy, use a firewall app to block Gboard’s network access entirely. This disables predictive text but ensures no typing data leaves your device:

Using AdAway or similar DNS-based blocker
Add the following domains to your blocklist:
www.googleapis.com (Gboard API endpoints)
gboard-data.googleapis.com
gstatic.com (fonts and resources)

Note that blocking network access may break some features like emoji suggestions and translation within Gboard.

Step 3 - Disable Data Collection in Samsung Keyboard

Samsung Keyboard (Samsung IME) collects data primarily for Samsung’s environment integration. Here’s how to minimize collection:

Turn Off Predictive Text and Learning

Open Settings > General Management > Samsung Keyboard Settings:

  1. Disable “Predictive text”
  2. Disable “Samsung Keyboard learning”
  3. Disable “Sync with Samsung Cloud”

These settings prevent Samsung from uploading typed text to analyze patterns.

Disable Send Usage Data

In the same settings menu, look for “Send usage data to Samsung” and disable it. This controls whether Samsung receives anonymized telemetry about keyboard usage patterns.

Block Samsung Keyboard Network Access

Similar to Gboard, you can block Samsung Keyboard’s network access:

Block Samsung Keyboard via ADB (requires root or Shizuku)
adb shell pm revoke com.samsung.android.lool android.permission.INTERNET

Be aware that some Samsung-specific features, like Samsung Pass integration, may stop working.

Step 4 - Privacy-Focused Keyboard Alternatives

Several keyboards prioritize privacy by design, storing all data locally:

AOSP Open Source Keyboard

The default AOSP keyboard included in pure Android distributions sends no data to any server. Enable it via Settings > System > Languages > Virtual Keyboard > Android Keyboard (AOSP). It lacks advanced predictive features but offers complete privacy.

AnySoftKeyboard

AnySoftKeyboard is an open-source keyboard available on F-Droid. It stores all dictionaries and learning locally:

Install from F-Droid (recommended for privacy)
Or build from source:
git clone https://github.com/AnySoftKeyboard/AnySoftKeyboard.git
cd AnySoftKeyboard
./gradlew assembleRelease

Configure AnySoftKeyboard to disable any optional network features and use local dictionaries only.

FlorisBoard

FlorisBoard is a modern, privacy-focused keyboard written in Kotlin:

Install via F-Droid or GitHub releases
Configure in settings:
Settings > Keyboard > Suggestions > Disable cloud suggestions
Settings > Data > Disable usage statistics

FlorisBoard supports emoji, GIF search (local-only), and clipboards without network communication.

Step 5 - For Developers: Implementing Privacy-Aware Input

When building applications that handle sensitive data, consider these approaches:

Use InputType flags Properly

Android’s InputType system tells keyboards what kind of data to expect. Properly setting these flags helps keyboards behave appropriately:

// For password fields
editText.inputType = InputType.TYPE_CLASS_TEXT or
                     InputType.TYPE_TEXT_VARIATION_PASSWORD

// For credit card numbers
editText.inputType = InputType.TYPE_CLASS_NUMBER or
                     InputType.TYPE_TEXT_VARIATION_PASSWORD

// For email addresses
editText.inputType = InputType.TYPE_CLASS_TEXT or
                     InputType.TYPE_TEXT_VARIATION_EMAIL_ADDRESS

Keyboards respect these flags and may adjust autocomplete behavior accordingly.

Implement Custom InputMethod

For sensitive applications, develop a custom InputMethod that processes input locally:

class SecureInputMethodService : InputMethodService() {
    override fun onCreateInputView(): View {
        // Render custom keyboard UI
        // Process all input locally without network calls
        return customKeyboardView
    }
}

Register it in your manifest with the android:permission.BIND_INPUT_METHOD permission.

Detect Keyboard Privacy Settings

Check whether users have disabled keyboard data collection in your app:

fun isKeyboardPrivacyEnabled(): Boolean {
    val gboardDisabled = Settings.Secure.getInt(
        contentResolver,
        "gboard_personalization_enabled",
        1
    ) == 0

    val samsungDisabled = Settings.Secure.getInt(
        contentResolver,
        "samsung_keyboard_learning_enabled",
        1
    ) == 0

    return gboardDisabled || samsungDisabled
}

This helps you warn users when typing data might be collected in fields requiring extra privacy.

Advanced - Network-Level Blocking

For enterprise or power user scenarios, consider network-level blocking:

Configure a Local DNS Resolver

Use Pi-hole or AdGuard Home to block known keyboard telemetry domains:

Pi-hole blocklist addition
keyboard-telemetry.google.com
kbdata.samsung.com
ime.samsung.com
gboard-sync.googleapis.com

Use a VPN with Blocking

Some VPN providers offer malware and tracker blocking. Route all traffic through such a VPN to catch any keyboard data attempts.

Step 6 - Verify Your Configuration

After implementing changes, verify data transmission is blocked:

  1. Use adb shell netstat to monitor network connections while typing
  2. Check with PCAP Droid to inspect outgoing packets
  3. Review your firewall logs for blocked keyboard connections
Monitor Gboard connections
adb shell tcpdump -i any -c 50 host google.com and port 443

Troubleshooting

Configuration changes not taking effect

Restart the relevant service or application after making changes. Some settings require a full system reboot. Verify the configuration file path is correct and the syntax is valid.

Permission denied errors

Run the command with sudo for system-level operations, or check that your user account has the necessary permissions. On macOS, you may need to grant terminal access in System Settings > Privacy & Security.

Connection or network-related failures

Check your internet connection and firewall settings. If using a VPN, try disconnecting temporarily to isolate the issue. Verify that the target server or service is accessible from your network.

Frequently Asked Questions

Who is this article written for?

This article is written for developers, technical professionals, and power users who want practical guidance. Whether you are evaluating options or implementing a solution, the information here focuses on real-world applicability rather than theoretical overviews.

How current is the information in this article?

We update articles regularly to reflect the latest changes. However, tools and platforms evolve quickly. Always verify specific feature availability and pricing directly on the official website before making purchasing decisions.

Does Go offer a free tier?

Most major tools offer some form of free tier or trial period. Check Go’s current pricing page for the latest free tier details, as these change frequently. Free tiers typically have usage limits that work for evaluation but may not be sufficient for daily professional use.

Can I trust these tools with sensitive data?

Review each tool’s privacy policy, data handling practices, and security certifications before using it with sensitive data. Look for SOC 2 compliance, encryption in transit and at rest, and clear data retention policies. Enterprise tiers often include stronger privacy guarantees.

What is the learning curve like?

Most tools discussed here can be used productively within a few hours. Mastering advanced features takes 1-2 weeks of regular use. Focus on the 20% of features that cover 80% of your needs first, then explore advanced capabilities as specific needs arise.

Related Articles

Built by theluckystrike. More at zovo.one