# ShizuCallRecorder: non-root call recording on Android 12+ through Shizuku > ShizuCallRecorder records both sides of carrier phone calls on a non-rooted phone by borrowing the shell user's permissions through Shizuku. It is simple by design, and that simplicity is also its main constraint. **kitsumed/ShizuCallRecorder** — ShizuCallRecorder empowers ADB through Shizuku to record phone calls on non-rooted device! - Repository: https://github.com/kitsumed/ShizuCallRecorder - Stars: 1,600 · Forks: 61 - Language: Kotlin - License: GPL-3.0 - Published: 2026-08-08 · Updated: 2026-08-18 · Language: en - Canonical page: https://hysenlabs.com/projects/kitsumed-shizucallrecorder ## The gap ShizuCallRecorder fills: carrier calls on a non-rooted phone Android 10 and later removed the ordinary app-level path to call audio, so most call recorders on the Play Store either fall back to the microphone, which misses the far end, or require root. ShizuCallRecorder takes a third route. It runs no root and no custom ROM, and it still claims to capture both sides of incoming and outgoing carrier calls. The README calls it the first non-root FOSS call recorder app for Android 11+. The intended user is narrow on purpose. The author writes that the application is meant to be a very basic call recorder that focuses solely on call recording for phone carriers, and that third-party app support is not the main focus. If you want a general purpose audio capture tool for WhatsApp or other VoIP services, this is not the project for you, and the README points at an open issue rather than a feature. The legal framing matters here. The disclaimer states that recording phone calls may be subject to complex and varying laws, that you may need consent from all parties, and that the app does not handle consent for you. Automatic recording in particular may not be permitted where you live. That is not a footnote on this project; it shapes when automatic mode is usable at all. ## How Shizuku and scrcpy-server give the app call audio Shizuku runs a process under the shell user, which on Android holds a long list of permissions that normal apps cannot request. The README links to the Shell app's AndroidManifest.xml on android.googlesource.com as the source of that permission set. ShizuCallRecorder talks to that shell process over the Shizuku API and executes capture work with privileges the app itself does not have. The capture layer is scrcpy-server, the same server binary the scrcpy project uses for mirroring and audio forwarding. The README describes ShizuCallRecorder as an on-device wrapper for scrcpy-server, which is an honest description of the architecture: the app is the control surface, and the heavy lifting is delegated to a component maintained elsewhere. That delegation has a cost the README states outright. The project uses hidden internal Android APIs, so it is prone to breaking in new Android releases or because of OEM modifications to the source code. The two named breaking points are scrcpy-server and Shizuku. Any upgrade to either can invalidate the capture path before the app's own code changes at all. On the app side, the README says the app runs only on phone event changes, with no persistent background process and no notifications. That is a deliberate trade-off: less battery and fewer background restrictions, but also less resilience. If a call state transition is missed, nothing is watching to correct it. ## Installing ShizuCallRecorder and recording a first call The README does not put the setup steps inline. It says you will need to do some initial configurations and directs you to the SUPPORT documentation under Installation & Configuration, with the build downloadable from the latest GitHub release. The package identifier is com.kitsumed.shizucallrecorder, and the project is also listed on F-Droid and the IzzyOnDroid repository. Install Shizuku first, since the app depends on it. Start Shizuku itself. The README recommends the thedjchi fork of Shizuku. On a non-rooted device Shizuku is normally started over ADB, and the README's requirement list points at Shizuku rather than documenting the command sequence, so follow the instructions in docs/SUPPORT.md for the exact steps on your device. With Shizuku running, open ShizuCallRecorder and grant it Shizuku access when prompted. The app exposes security toggles that manage the Shizuku on and off state. The README frames these as an attempt to reduce the attack surface Shizuku introduces and as a help for apps that complain when USB debugging or Shizuku is enabled, so expect to switch Shizuku off after setup if another app objects. For automatic recording, enable the option and then configure the exclusion rules. The README lists three: ignore anonymous calls, ignore specific contacts, and ignore all contacts. Choose the Opus or AAC codec for saved files. Then place a normal carrier call, incoming or outgoing, and check the recordings directory the app writes to. The README states that both sides should be captured even over Bluetooth or a remote headset. ## Where ShizuCallRecorder fails: concurrent calls, filter logic and Android 11 The README's application behavior warning is the most important part of the documentation, and it is unusually candid. Concurrent calls are a known failure mode. If a second call arrives while you are already in one, or you switch between held calls, the app may fail to detect the transition and continue recording audio into a single continuous file, with no separate notification or prompt for the later caller. For anyone who needs one file per conversation, that behavior breaks the assumption. Filter logic is the second weak point, and the cause is platform-level. The README says that because of Android privacy-driven restrictions on real-time phone number access, the app may rely, depending on the call detection mode, on fetching deprecated or unstable values. Those values feed the exclusion rules, so a rule that ignores a specific contact can behave differently depending on which detection mode is active and how the number is reported. Android 11 is listed as Limited support rather than Yes. The note is specific: an unlocked screen is required, otherwise the app crashes, and the README links to the relevant scrcpy server source. Android 12 through 16 are marked Yes, and Android 17 is marked Unknown with the comment that it is not yet released and has major ADB changes. The author also states plainly that they cannot extensively test all versions and that the table may change as other users report results. Finally, the project is not a surveillance tool and does not pretend to be one. It records carrier calls on the device it runs on. Questions about recording other people's messaging apps are outside what this code does. ## ShizuCallRecorder compared with root-based recorders and scrcpy The closest alternative in kind is a root-based call recorder. Those apps run with full system privileges and can hook the audio path directly, which removes the dependency on Shizuku and on a bundled server binary. The difference in practice is the barrier to entry: rooting voids warranties, trips banking and DRM checks, and is impossible on many locked bootloaders. ShizuCallRecorder trades that permanence for a Shizuku session you start over ADB. The cost is that the privilege is borrowed, not owned, so the app is only as stable as the shell permission set it depends on. The second alternative is scrcpy itself. The README notes that ShizuCallRecorder can be seen as an on-device wrapper for scrcpy-server, so a technically comfortable user could drive scrcpy-server directly and capture audio without this app. What ShizuCallRecorder adds is call event detection, the automatic recording rules, and file naming, all in an Android UI. If you already run scrcpy from a desktop and only need occasional capture, the wrapper may be more machinery than you need. The third option is the built-in recorder some OEMs ship. Those are vendor-specific, often region-locked, and not FOSS. ShizuCallRecorder's reason for existing, as the author puts it, is that no other FOSS call recording app for non-root devices existed, and the GPL-3.0 choice is intended to keep any future alternatives open. ## Maintenance, licensing and what a GPL-3.0 recorder commits you to The repository is not archived, and the last push was on 2026-08-12, which is the same date as the v1.3.3 release. Two earlier releases, v1.3.2 and v1.3.1, landed in the weeks before that, so the project has seen recent tagged activity. The README's own warning still applies regardless of release cadence: hidden APIs mean an Android update or an OEM change can break capture between releases, and the two named dependencies, scrcpy-server and Shizuku, are outside the author's control. The code is GPL-3.0 with additional terms under Section 7 at the end of the LICENSE file. Those terms withhold trademark rights: the README gives ShizuCallRecorder and com.kitsumed.shizucallrecorder as property of the copyright holder, kitsumed. Practically, that means a fork must not ship under the same name or package identifier, and the Section 7 text is worth reading before you publish a modified build. This is a description of the licence, not legal advice. Upgrade cost is mostly about verification, not code. Because the app relies on a bundled server and a separate Shizuku app, updating either one is a change to your capture path. The Android Tested Versions table is the project's own statement of where that path is known to work, and it explicitly invites testing by other users because the author cannot cover every device. ## Conclusion Adopt ShizuCallRecorder if you record your own carrier calls on a non-rooted Android 12 or newer phone, you are willing to run Shizuku, and you accept hidden-API fragility and the legal duty to inform the other party. Do not adopt it if you need third-party VoIP apps, unattended operation on an unlocked-screen Android 11 device, or a recorder that survives every OEM firmware update without intervention. Before installing, read docs/SUPPORT.md end to end, check the Android Tested Versions table against your exact model, and confirm what your jurisdiction requires for consent. ## FAQ ### Does ShizuCallRecorder need root? No. The README describes it as a non-root FOSS call recorder for Android 11+ that uses Shizuku and ADB to reach the shell application's permission set. Shizuku itself must be running for the app to capture audio. ### Which Android versions does ShizuCallRecorder support? The requirements section lists Android 12 or newer, with Android 11 marked Limited because an unlocked screen is required or the app crashes. Android 12 through 16 are marked Yes, and Android 17 is marked Unknown because it is not yet released and has major ADB changes. ### What happens if a second call arrives while ShizuCallRecorder is recording? The README warns that the app may fail to detect the transition and continue recording audio into a single continuous file, without a separate notification or prompt for the later caller. The same applies when switching between held calls. ### Is using a call recorder apk legal? The README states that recording phone calls may be subject to complex and varying laws, that you may need consent from all parties, and that the app does not handle consent for you. It points to Wikipedia's telephone call recording laws page and says to consult a legal professional. ### Can ShizuCallRecorder record third-party app calls? The README says the app focuses solely on call recording for phone carriers and that third-party app support is not the main focus. It links to an open issue that would need to be addressed first. ## Sources - [Official README](https://github.com/kitsumed/ShizuCallRecorder#readme) - [Project repository](https://github.com/kitsumed/ShizuCallRecorder) - [Release notes](https://github.com/kitsumed/ShizuCallRecorder/releases) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/kitsumed-shizucallrecorder