React Native Wake Word Detection in 2025: The Complete Guide

TLDR:

This comprehensive React Native Wake Word guide explains how to implement wake word detection to enable hands-free activation, like "Hey Siri" or "Alexa" in React Native apps. It covers React Native wake word options developers have, provides step-by-step implementation instructions for Porcupine, which is the only ready-to-use, publicly available wake word option for React Native apps, explains wake word configuration and performance optimization options, and includes troubleshooting tips.

What is Wake Word Detection?

Wake word detection (also called hotword detection, keyword spotting, or voice triggers) activates applications when end-users say a specific phrase, similar to how "Hey Siri" or "Alexa" work on smart speakers and mobile devices.

Instead of constantly processing all audio, wake word detection runs a lightweight AI model that listens for a special phrase wake word. Once detected, your app can activate speech recognition, execute commands, or trigger specific features, creating natural, hands-free voice experiences while preserving battery life and protecting user privacy.

The Current State of React Native Wake Word Detection

If you've searched for React Native wake word solutions, you might have encountered discontinued libraries, research projects, or confusing information. Here are the wake word alternatives for React Native applications in 2025:

Porcupine Wake Word

Porcupine Wake Word is the only voice activation option for enterprises with a publicly available, official React Native SDK, instant custom wake word training, and self-service deployment, without requiring enterprise sales engagement. It's proven in production by Fortune 500 companies and startups.

Sensory TrulyHandsfree

Sensory TrulyHandsfree is an enterprise solution with a long track record. There is no publicly available information on TrulyHandsfree React Native support. However, developers can contact the sales team to explore further.

SoundHound Houndify

SoundHound Houndify is an enterprise solution that offers two wake word tiers: proof-of-concept (low-cost version, delivered in weeks) and production-grade. React Native is supported for the Houndify platform. However, there is no information on how to train and integrate custom wake words, requiring developers to contact the sales team.

openWakeWord

openWakeWord is open-source wake word detection, popular among open-source enthusiasts, especially within the HomeAssistant community. Although there is no official React Native support, since ONNX runtime supports React Native and openWakeWord is open source, developers can port openWakeWord to integrate it into React Native apps.

Spokestack

The previously popular solution archived all repositories in 2022 and shut down. While their website, GitHub page, and documentation still appear in search results, it's no longer maintained.

Snowboy

Snowboy itself is not a React Native library. However, since it's a C++ library, it can be integrated into React Native projects through native modules (e.g., using a bridge to expose its functionality to JavaScript). Despite being a popular solution in the past, Snowboy hasn't been maintained for years. Due to its low accuracy and high resource utilization, Snowboy is no longer recommended for enterprise applications, considering the recent advances in voice AI.

Other alternatives

Many individual developers build their own wake words leveraging open-source keyword spotting datasets and open-source runtimes, such as PyTorch, TensorFlow, TensorFlow Lite, and ONNX.

Best Wake Word Library for React Native Applications

Usually, the answer to the best engine depends on your specific requirements. However, for React Native wake word detection, Porcupine Wake Word is the clear choice because it's the only solution that offers:

• Official support for React Native (iOS & Android)
• Custom wake word training in seconds
• Active maintenance and documentation
• Industry-leading accuracy and performance

Step-by-Step Guide to Add Wake Word to React Native Apps

Prerequisites

Before starting, ensure you have:

• Android (5.0+, API 21+)
• iOS (13.0+)
• React Native 0.63+
• Picovoice AccessKey (create a free account at console.picovoice.ai)

Step 1: Configure Microphone Permissions

Wake word detection requires microphone access. Set up permissions for both platforms:

iOS Permissions

Add the following block to Info.plist:

<key>NSMicrophoneUsageDescription</key>
<string>[Permission explanation]</string>

Android Permissions

Add the following block to AndroidManifest.xml:

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.RECORD_AUDIO" />

Step 2: Install Porcupine Wake Word React Native Packages

npm install @picovoice/react-native-voice-processor @picovoice/porcupine-react-native

What these packages do:

• @picovoice/react-native-voice-processor: Handles audio capture from device microphone
• @picovoice/porcupine-react-native: Porcupine wake word engine bindings

Step 3: Get Your Picovoice AccessKey

1. Sign up for a free account at console.picovoice.ai
2. Copy your AccessKey from the dashboard

Step 4: Train Custom Wake Word Models

While Porcupine Wake Word includes built-in wake words like "porcupine" and "bumblebee" for testing, enterprise applications need custom wake words unique to the product or brand.

1. Go to Picovoice Console
2. Navigate to "Porcupine Wake Word"
3. Select the language (English, French, Spanish, German…)
4. Type your wake word phrase
5. Click on "Train" to train a wake word
6. Download the trained custom wake word models for Android and iOS

Wake Word Selection Best Practices

Characteristics of good wake words:

• 2-3 words long (combinations that are less likely to occur in normal conversation)
• Phonetically distinct
• Easy to pronounce naturally

Avoid:

• Single-syllable words
• Common phrases used in everyday speech
• Complex pronunciation, tongue-twisters, or long phrases

For detailed guidance, see Picovoice's wake word selection guide and learn about personalized activation using wake words and voice ID together.

Step 5: Add Wake Word Models to Your React Native Project

• Android: Add the Android keyword file to the assets folder (${ANDROID_APP}/src/main/assets).
• iOS: add the iOS keyword file to the Copy Bundle Resources step.

Step 6: Implement Wake Word Detection in React Native

Here's a complete, production-ready implementation:

import React, { useRef, useState } from "react";
import { Button, Platform, View } from "react-native";
import { PorcupineManager } from '@picovoice/porcupine-react-native';

const ACCESS_KEY = "${ACCESS_KEY}"; // Your Picovoice Console AccessKey
const KEYWORD_FILE_PATH = "${KEYWORD_FILE_PATH}" // e.g. `ananas_${Platform.OS}.ppn`
const MODEL_FILE_PATH = "${MODEL_FILE_PATH}" // e.g. "porcupine_params_de.pv" (if non-English keyword)

enum PorcupineState { Initial, Created, Listening }

export default function Porcupine() {
  const [porcupineState, setPorcupineState] = useState(PorcupineState.Initial);
  const porcupineManager = useRef(null);

  // 1. Handle keyword detection
  const detectionCallback = (keywordIndex: number) => {
    if (keywordIndex === 0) {
      console.log("Keyword detected")
    }
  };

  // 2. Handle error
  const processErrorCallback = (error) => {
    console.error(error);
  };
  
  // 3. Initialize PorcupineManager
  const ppnCreate = async () => {
    try {
      porcupineManager.current = await PorcupineManager.fromKeywordPaths(
        ACCESS_KEY,
        [KEYWORD_FILE_PATH],
        detectionCallback,
        processErrorCallback,
        MODEL_FILE_PATH, // (if non-English keyword)
      );
      setPorcupineState(PorcupineState.Created);
    } catch (err) {
      console.error(err);
    }
  }

  // 4. Start & stop keyword detection
  const ppnStart = async () => {
    try {
      await porcupineManager.current.start();
      setPorcupineState(PorcupineState.Listening);
    } catch (err) {
      console.error(err);
    }
  }

  const ppnStop = async () => {
    try {
      await porcupineManager.current.stop();
      setPorcupineState(PorcupineState.Created);
    } catch (err) {
      console.error(err);
    }
  }

  // 5. Release resources
  const ppnDelete = async () => {
    try {
      await porcupineManager.current.delete();
      setPorcupineState(PorcupineState.Initial);
    } catch (err) {
      console.error(err);
    }
  }

  return (
    <View>
      <Button title="Create Porcupine" onPress={ppnCreate} disabled={porcupineState !== PorcupineState.Initial} />
      <Button title="Start Listening" onPress={ppnStart} disabled={porcupineState !== PorcupineState.Created} />
      <Button title="Stop Listening" onPress={ppnStop} disabled={porcupineState !== PorcupineState.Listening} />
      <Button title="Delete Porcupine" onPress={ppnDelete} disabled={porcupineState !== PorcupineState.Created} />
    </View>
  );
}

Understanding the Code

Key components:

1. Detection callback: Fires when the wake word is detected, receives the keyword index
2. Error callback: Handles any errors during audio processing
3. PorcupineManager initialization: Initializes the wake word detection engine
4. Start/Stop methods: Control audio capture and wake word detection
5. Cleanup: Important to properly release resources when done

Optional Wake Word Configurations

1. Adjusting Wake Word Sensitivity

Porcupine Wake Word React Native API allows developers to adjust the sensitivity, which trades miss rate for false alarm while adding wake word detection to their applications. Sensitivity is a floating-point number within [0, 1].

• Higher Sensitivity: Higher detection with increased false alarms
• Lower Sensitivity: Fewer false alarm rates with higher miss rates

const porcupineManager = await PorcupineManager.fromKeywordPaths(
  "${ACCESS_KEY}",
  ["bumblebee_${Platform.OS}.ppn"],
  detectionCallback,
  processErrorCallback,
  "${MODEL_FILE_PATH}",
  [0.5] // sensitivity for keyword: "Bumblebee"
);

2. Detecting Multiple Wake Words

Porcupine Wake Word can detect multiple wake words simultaneously with no added runtime footprint. Porcupine Wake Word comes with built-in keywords, which are: "Alexa", "Americano", "Blueberry", "Bumblebee", "Computer", "Grapefruit", "Grasshopper", "Hey Google", "Hey Siri", "Jarvis", "Ok Google", "Picovoice", "Porcupine", "Terminator". Product teams can train custom wake word models or use the built-in ones to give end-users alternatives, elevating user experience. For example, you could detect both "Hey Jarvis" (built-in) and "Hey MyApp" (custom) in the same application.

const porcupineManager = await PorcupineManager.fromKeywordPaths(
  "${ACCESS_KEY}",
  [
    "hey_jarvis_${Platform.OS}.ppn",  // pass multiple keyword files
    "hey_myapp_${Platform.OS}.ppn"    // for simultaneous detection
  ],
  detectionCallback,
  processErrorCallback,
  "${MODEL_FILE_PATH}",
  [0.5, 0.75] // sensitivities: "Hey Jarvis" [0.5] & "Hey MyApp" [0.75]
);

3. Detecting Non-English Wake Words

Developers can train custom wake words in English, Chinese, French, German, Italian, Japanese, Korean, Portuguese, and Spanish. Download the corresponding language model and pass it via modelPath.

const porcupineManager = await PorcupineManager.fromKeywordPaths(
  "${ACCESS_KEY}",
  [
    "keywords/ananas_${Platform.OS}.ppn", // e.g. German keywords
    "keywords/heuschrecke_${Platform.OS}.ppn"
  ],
  detectionCallback,
  processErrorCallback,
  "porcupine_params_de.pv", // e.g. German language model file
);

React Native Wake Word Production Deployment Checklist

Review this checklist before deploying your React Native app with wake word detection:

Performance

• Test on low-end Android and iOS devices
• Monitor battery usage during extended listening sessions
• Test wake word detection latency

User Experience

• Request microphone permission with a clear explanation
• Provide visual feedback when listening for the wake word
• Show a clear indication when the wake word is detected
• Allow end-users to enable/disable wake word detection

Testing

• Test with diverse accents and speech patterns
• Verify behavior with background noise, music, and overlapping speech
• Test each wake word model; if multiple wake words are supported
• Validate sensitivity settings for your use case

Common Wake Word Detection Errors and Solutions

1. "Permission Denied" Error on Android or iOS

Problem: App fails to start listening (keyword not being detected)

Solutions:

• Verify microphone permission is requested and granted
• iOS: Check that Info.plist has the NSMicrophoneUsageDescription key
• Android: Check that AndroidManifest.xml has the RECORD_AUDIO tag

2. Wake Word Not Being Detected

Problem: Custom wake word doesn't trigger detection reliably

Solutions:

• Increase the sensitivity value
• Test in a quiet environment first
• Ensure you're pronouncing the wake word clearly

3. High False Positive Rate

Problem: Wake word triggers too frequently by mistake

Solutions:

• Lower the sensitivity value (try 0.3-0.4)
• Try a new wake word with more distinctive sounds and avoid common words, especially if you're using a single word.

4. Memory Leaks in React Native

Problem: App memory usage grows over time

Solution:

• Always call PorcupineManager.delete() when you no longer need keyword detection to free memory
• Test with React Native DevTools memory profiler

Performance Benchmarks

1. Accuracy

97%+ true positive rate with <1 false alarm per hour across six keywords (alexa, computer, jarvis, smart mirror, snowboy, and view glass) from more than 50 distinct speakers and 18 different noise environments at 10dB SNR.

2. CPU Usage

Porcupine Wake Word is designed for resource-constrained mobile devices. The CPU usage depends on the hardware and software choices of developers. Porcupine Wake Word's CPU Usage is <4% on a Raspberry Pi 3.

• How to Benchmark a Wake Word Detection Engine
• Understanding Wake Word Benchmarks
• Reproduce the Open-Source Benchmark Framework

3. Mobile Device Battery Usage

Battery usage depends on hardware and the actual state of the battery. Porcupine leverages Picovoice's end-to-end optimization, offering the most efficient and lightweight solution available.

The legacy approach to on-device voice AI requires data gathering and model training dedicated to each project, using repurposed server runtimes such as PyTorch and ONNX. Since these runtimes aren't designed for edge deployment, they carry significant runtime overhead.

Picovoice owns, builds, and optimizes the entire process from data pipelines, training, and inference, creating lightweight engines perfect for mobile applications built in React Native.

Next Steps: Building Complete Voice Experiences

Once you have wake word detection working in React Native, enhance your voice interface with other Picovoice technologies:

• Use Rhino Speech-to-Intent to add domain-specific complex voice commands by inferring user intent and intent details directly from speech.
• Use Cheetah Streaming Speech-to-Text to transcribe end-user utterances for note-taking or combine with LLMs to create voice AI agents.

Additional Resources

Documentation

• Porcupine Wake Word React Native Quick Start
• Porcupine Wake Word React Native API Documentation
• React Native Voice Processor Quick Start
• React Native Voice Processor API Documentation
• Official React Native Wake Word Demo

Learning Resources

• Complete Guide to Wake Words
• Custom Wake Words with Voice ID
• Keyword Spotting in Voice Recognition
• Wake Word Detection React Native Tutorial
• Complete Guide to Speech Recognition in React Native

Conclusion

Wake word detection transforms how end-users interact with your React Native app, enabling natural, hands-free voice experiences. Porcupine Wake Word is an accurate, production-ready, lightweight wake word detection engine with a professionally maintained React Native SDK and custom wake word models trained in seconds.

Key takeaways:

• Porcupine Wake Word is currently the only publicly available and commercially maintained solution to add custom wake words to React Native apps in minutes.
• Custom wake words are easy to create with Picovoice Console
• Integrating custom wake words takes less than fifteen minutes with the code examples in this guide

Start free to create voice-activated, hands-free React Native apps today with a free Picovoice account.

Frequently Asked Questions