Monkey testing throws random inputs at your app to find crashes, ANRs (Application Not Responding errors), and stability issues that structured testing misses. A monkey test doesn't follow a script. It taps random spots, types random text, swipes in random directions, and rotates screen. If app crashes, you found a bug.
What is monkey testing in practice? It's chaos with a purpose. You hand your app to a tool that behaves like a user who has no idea what app does, then see what breaks. The value is in finding crashes and edge cases that no QA engineer would think to test because no reasonable user would do those things. Except users do, all time.
This covers how monkey testing works on Android and iOS, tools available, how it differs from chaos engineering, how to integrate it with your testing strategy, and how to turn random crash reports into actionable bugs.
What is monkey testing vs chaos monkey?
These two concepts share a name but solve different problems. Most people searching for "chaos monkey" or "monkey testing" conflate them.
Chaos monkey software is part of Netflix's Simian Army, a set of tools that netflix chaos monkey team built to test infrastructure resilience by introducing failures in production. What is chaos monkey? It randomly terminates instances in production to ensure that services handle failures gracefully. Chaos monkey Netflix built this approach after moving to AWS to ensure their streaming service survived server failures.
Monkey testing is different. It targets application layer, not infrastructure. An android monkey test generates random touch events, gestures, and system events on a mobile app to find crashes. The chaos monkey testing approach tests backend systems. Monkey software testing targets app itself.
For mobile QA teams, software monkey testing is relevant concept. It catches crashes that happen during random interactions, including bugs triggered by push notifications arriving mid-flow or device state changes. Monkey testing in android is well-supported through built-in tools. Chaos engineering is valuable too, but it's an infrastructure concern, not a mobile app testing technique.
How does android monkey testing work?
Android has a built-in monkey testing tool called Application Exerciser Monkey. It ships with Android SDK and runs from command line through ADB.
The basic command:
adb shell monkey -p com.yourapp.package -v 10000
This sends 10,000 random events to your app. The -p flag restricts events to your app's package. The -v flag enables verbose logging so you can see what happened when (and if) app crashes.
Useful flags for more controlled monkey testing:
# Throttle events to 300ms apart (more realistic timing)
adb shell monkey -p com.yourapp.package --throttle 300 -v 10000
# Set seed for reproducible runs (same seed = same random sequence)
adb shell monkey -p com.yourapp.package -s 42 -v 10000
# Control event distribution (70% touch, 15% motion, 15% system)
adb shell monkey -p com.yourapp.package \
--pct-touch 70 --pct-motion 15 --pct-syskeys 15 -v 10000
# Ignore crashes and keep running (collect all crashes, not just first)
adb shell monkey -p com.yourapp.package --ignore-crashes -v 10000
The monkey tool generates events including screen taps, swipes, pinch gestures, key presses, device rotation, and system events (home button, back button, volume). It's essentially a UI-level stress test that doesn't need any test scripts.
An android monkey test typically runs for 50,000 to 500,000 events depending on app complexity. A 100,000-event run takes 15 to 30 minutes with a 300ms throttle. Most crashes surface within first 50,000 events.
How do you run monkey testing on iOS?
iOS has no built-in monkey testing tool equivalent to Android's Application Exerciser Monkey. This is gap most guides skip entirely.
Your options for iOS monkey testing:
- XCUITest with randomized inputs: Write an XCUITest that generates random tap coordinates, swipe directions, and text input. You control randomization logic. This requires coding but gives you full control over event types and distribution.
- Appium with random gestures: Script an Appium test that generates random touch actions on iOS simulator or real device. Same concept as Android tool but requires more setup.
- Third-party tools: Tools like WeTest, Testabot, and some cloud testing platforms offer iOS monkey testing as a service. You upload your IPA and they run random events on real devices.
- Drizz for smart monkey testing: Instead of blind random taps, you can use Drizz to run semi-structured tests that explore your app's flows with variation. Vision AI sees screen and interacts intelligently, covering more of app's functionality than pure random input would. This catches same stability issues as traditional monkey testing while also validating that screens render correctly.
For most iOS teams, XCUITest approach is most practical because it runs in your existing test infrastructure and integrates with CI/CD.
What are types of monkey testing?
Monkey testing has three levels of intelligence:
- Dumb monkey testing uses completely random inputs with zero knowledge of app. The tool taps random coordinates, enters random strings, and performs random gestures. It finds crashes and ANRs but spends most of its time on meaningless actions (tapping empty space, entering text in non-input fields). The Android Monkey tool operates at this level.
- Smart monkey testing uses some knowledge of app's UI to generate more targeted random inputs. It identifies tappable elements and focuses random actions on them. This covers more of app's functionality in fewer events. Tools like Appium with element discovery or Vision AI approaches operate at this level.
- Brilliant monkey testing combines random exploration with state awareness. It tracks which screens it has visited, which buttons it has tapped, and which paths remain unexplored. It systematically covers more of app while still introducing random variation. This overlaps with model-based testing where a model guides exploration.
For most mobile teams, dumb monkey testing (Android Monkey tool) is starting point. It's free, requires zero setup, and catches most obvious stability issues. Smart monkey testing adds value when you want better coverage without writing structured tests.
How do you integrate monkey testing into CI/CD?
Running monkey tests manually defeats purpose. The value comes from running them automatically on every build or nightly.
Here's how to add monkey testing to your CI/CD pipeline:
# GitHub Actions example for Android monkey testing
- name: Run monkey test
run: |
adb shell monkey -p com.yourapp.package \
--throttle 300 \
--ignore-crashes \
--ignore-timeouts \
-s ${{ github.run_number }} \
-v 50000 2>&1 | tee monkey_log.txt
- name: Check for crashes
run: |
if grep -q "CRASH" monkey_log.txt; then
echo "Monkey test found crashes!"
exit 1
fi
Run monkey tests after your functional test suite passes. Monkey testing catches stability issues that structured tests miss, but it shouldn't replace your regression suite. Think of it as an extra layer that runs after your push notification tests, deep link validation, and core flow automation.
A practical schedule: run 50,000 events on every nightly build. Run 200,000 events on release candidates. Use a fixed seed per build number so crashes are reproducible.
How do you triage monkey test results?
Monkey tests generate a lot of noise. Not every crash is a real bug. Here's how to triage effectively:
The key is separating crashes that users will actually hit from crashes that only happen under extreme random input. A crash on device rotation in checkout flow is high priority because real users rotate their phones. A crash from entering emoji in a phone number field is lower priority (but still worth fixing).
Use -s (seed) flag to reproduce crashes. Same seed, same event count, same crash. This turns a random failure into a reproducible bug report your developers can debug.
What does a real before and after look like?
A food delivery app team shipped weekly and relied on manual QA and automated regression tests. Their regression suite covered 150 structured test flows. They caught functional bugs consistently but kept getting 1-star reviews mentioning crashes "when I tap around fast" or "when I rotate phone during checkout."
They added monkey testing to their nightly CI pipeline:
- 100,000 random events per nightly build on 3 Android devices
- Fixed seed based on build number for reproducibility
- Crash logs parsed and auto-filed as bug tickets
- XCUITest-based random input suite for iOS (5,000 events per run on simulator)
In first week, monkey testing found 7 crashes their regression suite never hit:
- An ANR when rapidly switching between tabs
- A crash on device rotation during payment processing
- A null pointer when app received a push notification while order confirmation screen was loading
- Four crashes in edge cases involving rapid back-button presses
They fixed all 7 in one sprint. Crash-related 1-star reviews dropped by 60% over next month.
The team now treats monkey testing as a permanent part of their pipeline, running alongside their Drizz regression suite. Structured tests catch functional bugs. Monkey tests catch stability bugs. Together they cover what users actually experience. Tools like Drizz complement monkey testing by handling structured side (plain English tests on real devices with Vision AI) while Monkey tool handles chaos side.
FAQs
What is monkey testing?
Monkey testing is a software testing technique that sends random inputs (taps, swipes, text, gestures, system events) to an app to find crashes and stability issues. It doesn't follow a script. The goal is to uncover bugs that structured testing misses by simulating unpredictable user behavior. The monkey testing meaning is simple: throw chaos at app and see what breaks.
What is chaos monkey and how is it different?
Chaos Monkey is a Netflix-built tool that randomly kills production servers to test infrastructure resilience. It's a chaos engineering tool for backend systems. Monkey testing is an app-level technique that sends random UI inputs to find crashes. Chaos monkey netflix created is about server reliability. Monkey testing is about app stability. Different layers, different purpose.
How do you run an android monkey test?
Use command adb shell monkey -p com.yourapp.package -v 10000 to send 10,000 random events to your app. Add --throttle 300 for realistic timing, -s 42 for a reproducible seed, and --ignore-crashes to collect all crashes instead of stopping at first one. The tool ships with Android SDK and needs no additional setup.
Can you do monkey testing on iOS?
iOS has no built-in monkey testing tool. Your options are writing XCUITest scripts with randomized inputs, using Appium with random gestures, using third-party cloud testing services, or using Vision AI tools like Drizz for smart monkey testing that explores app intelligently instead of tapping blindly.
How does monkey testing fit into a testing strategy?
Run monkey testing after your structured test suite passes. Structured tests (regression, E2E, smoke) catch functional bugs. Monkey tests catch stability bugs (crashes, ANRs, unhandled exceptions). Run 50,000 events nightly and 200,000 on release candidates. Use a fixed seed for reproducibility.
What is smart monkey testing?
Smart monkey testing uses knowledge of app's UI to generate targeted random inputs instead of blind taps. It identifies tappable elements and focuses on them, covering more functionality in fewer events. Vision AI approaches take this further by understanding screen content and navigating app intelligently while still introducing random variation.
