1.Quick Start and Installation

Introduction and Core Benefits

Scrcpy, pronounced "screen copy," represents a fundamental shift in how we interact with Android devices from our computers. At its core, it's a command-line application that mirrors Android device screens—both video and audio—while enabling full control via keyboard and mouse. What sets it apart from countless alternatives is its uncompromising philosophy: no root access required, no apps to install on the device, no accounts to create, and no network dependencies. The tool works entirely through the standard Android Debug Bridge (ADB) protocol, establishing a direct, efficient connection between your computer and device.

The project emerged from a simple frustration with existing solutions that either demanded intrusive permissions, injected ads into the experience, or introduced unacceptable latency. The name itself reflects the minimalist approach—scr-screen-cpy, a straightforward tool that does exactly what it says. This simplicity extends beyond the name. Scrcpy is native software, built with performance as the primary constraint rather than an afterthought. While many screen mirroring tools wrap web technologies or rely on cloud intermediaries, scrcpy operates at the system level, leveraging FFmpeg for media processing and SDL2 for rendering. The result is a remarkably lightweight binary that delivers 30 to 120 frames per second depending on your device, with latency as low as 35-70 milliseconds—fast enough for gaming, precise enough for development work.

The non-intrusive nature deserves emphasis. When you disconnect, nothing remains on your device. No background services, no persistent daemons, no telemetry. This makes it ideal for enterprise environments, security-conscious users, and developers who need a clean testing workflow. The tool supports Android 5.0 (API 21) and newer, covering virtually every device still in active use. Audio forwarding, introduced in version 2.0, requires Android 11+, while camera mirroring needs Android 12+. These features aren't arbitrary limitations—they reflect genuine Android platform capabilities that scrcpy exposes rather than works around.

Beyond basic mirroring, scrcpy has evolved into a comprehensive device interaction platform. It can record your screen to video files, create virtual displays for multitasking, simulate physical keyboards and mice using HID protocols, forward gamepad inputs, and even expose your device camera as a webcam on Linux systems. The OTG mode lets you control devices without mirroring, useful for automation or when you only need input injection. Each feature follows the same principle: do one thing well, keep latency minimal, and respect user privacy.

For developers, scrcpy transforms the debugging workflow. Instead of constantly switching between your desk and device, you can keep the phone on a stand while interacting with it through your development machine. For content creators, it enables high-quality screen recordings without watermarks or quality degradation. For everyday users, it means typing long messages with a real keyboard, managing notifications without picking up your phone, or running mobile apps in a window alongside desktop applications. The versatility stems from deliberate design choices that prioritize user control over convenience for the developer.

Prerequisites and Environment Setup

Before installing scrcpy, we need to establish a proper foundation. The requirements are modest but specific, and skipping these steps inevitably leads to the connection issues documented extensively in community forums. Let's address them systematically.

Android Device Requirements

First, verify your device runs Android 5.0 (Lollipop) or newer. While scrcpy technically supports API 21, modern features demand newer versions. Audio forwarding requires Android 11 (API 30) or higher. Camera mirroring, a more recent addition, needs Android 12 (API 31). These aren't arbitrary cutoffs—they map to when Google introduced the necessary system APIs for secure, low-latency media capture. To check your version, open Settings, navigate to About Phone, and examine the Android version entry.

More critically, you must enable USB debugging. This option resides in Developer Options, which Android hides by default. To reveal it, go to Settings → About Phone and tap the Build Number seven times. A countdown appears, and after the seventh tap, Developer Options unlocks. Return to the main Settings menu, find Developer Options, and enable USB Debugging. When you first connect your device to a computer via USB, a popup appears requesting authorization. Always check "Always allow from this computer" to avoid repeated prompts.

Some manufacturers, particularly Xiaomi, Oppo, and Vivo, implement additional security layers. If you encounter errors about injecting input events or missing permissions, enable "USB Debugging (Security Settings)"—a separate option from the standard USB debugging. This grants the shell permission to simulate input and control the device. After enabling this, reboot your device. The setting won't take effect until the system restarts. This requirement trips up many users who enable the option but skip the reboot, then wonder why control features fail.

For wireless connections, Android 11 introduced a Wireless Debugging option in Developer Options that simplifies the process. Older devices require initial USB connection to enable TCP/IP mode. We'll cover both methods later, but the prerequisite remains: Developer Options must be visible and USB debugging enabled.

Computer Requirements

Scrcpy runs on Linux, Windows, and macOS. The binaries are statically linked where possible, minimizing dependency hell. On Linux, you'll need FFmpeg and SDL2 libraries, but modern distributions include these by default. Windows users need no additional runtime libraries—the release packages bundle everything. macOS requires Homebrew or MacPorts for installation, which handle dependencies automatically.

The computer must have ADB (Android Debug Bridge) accessible from the command line. Many installation methods include ADB, but verifying its presence prevents later headaches. Open a terminal or command prompt and type adb version. If you see version information, you're set. If not, you'll need to install the Android SDK Platform Tools. On Windows, scrcpy releases include adb.exe in the current directory, which works because Windows includes the current directory in PATH by default. Linux and macOS users should install ADB through their package manager.

ADB Verification and Setup

ADB is the communication backbone. Scrcpy doesn't implement its own USB drivers or network protocols—it leverages ADB's established, reliable channels. This design choice means any ADB connectivity issue directly impacts scrcpy. Let's verify ADB is working correctly.

Connect your Android device via USB. Run adb devices in your terminal. You should see output like:

List of devices attached
0123456789abcdef        device

The hexadecimal string is your device serial. If the list is empty, several culprits exist: faulty USB cables (many cables are charge-only), missing drivers on Windows, or USB debugging not enabled. Try different cables and ports first—this solves most issues. On Windows, you may need the Google USB Driver for Nexus/Pixel devices or OEM-specific drivers for other manufacturers.

If you see "unauthorized" instead of "device," the authorization popup either didn't appear or was denied. Disconnect the USB cable, revoke USB debugging authorizations in Developer Options, reconnect, and accept the popup when it reappears. This forces the system to generate a new RSA keypair for authentication.

For wireless setups, ADB must be version 31 or newer to support the modern pairing process. Check with adb version and upgrade if necessary. The platform-tools package updates independently of the Android SDK, so even seasoned developers sometimes run outdated ADB versions.

Device Preparation Checklist

Before proceeding to installation, run through this checklist:

• Device runs Android 5.0+ (11+ for audio, 12+ for camera)
• Developer Options unlocked via seven build number taps
• USB debugging enabled
• For Xiaomi/Oppo/Vivo: USB debugging (security settings) enabled and device rebooted
• Device connected via reliable USB cable
• adb devices shows device as "authorized"
• For wireless: ADB version 31+ installed

This preparation takes five minutes but saves hours of troubleshooting. The scrcpy FAQ is filled with issues that trace back to skipped prerequisites. The tool is robust, but it can't compensate for a device that refuses ADB connections.

Multi-platform Installation Methods

Scrcpy offers multiple installation paths for each platform. The official releases provide static binaries that work out-of-the-box. Package managers offer convenience but sometimes lag behind the latest version. Building from source gives you the bleeding edge but requires development tools. We'll explore each option, noting when to choose which path.

Linux Installation

Linux users have three primary installation methods: direct download, package manager, or build script. Each suits different needs.

Official Static Build

The simplest method downloads a prebuilt binary from the GitHub releases page. The Linux archive contains a single binary that runs on any x86_64 distribution with a recent kernel. Extract the tarball and run scrcpy immediately. This approach isolates scrcpy from system package updates, ensuring stability.

To install, download scrcpy-linux-x86_64-v3.3.4.tar.gz (or the latest version). Extract it:

tar -xzf scrcpy-linux-x86_64-v3.3.4.tar.gz
cd scrcpy-linux-x86_64-v3.3.4
./scrcpy

The binary expects ADB in PATH. If you haven't installed platform-tools, do so now:

# Debian/Ubuntu
sudo apt install android-sdk-platform-tools

# Fedora
sudo dnf install android-tools

# Arch
sudo pacman -S android-tools

Static builds are experimental but highly reliable. They bundle FFmpeg and SDL2, avoiding dependency conflicts. For system integration, manually copy the binary to /usr/local/bin and the man page to /usr/local/share/man/man1.

Package Manager Installation

Most distributions package scrcpy, but version freshness varies. Arch Linux maintains the latest release in its official repositories. Fedora users can enable a COPR repository for up-to-date builds. Debian and Ubuntu lag significantly—their repositories often contain versions two years old, missing critical features and bug fixes.

For Arch:

sudo pacman -S scrcpy

For Fedora:

sudo dnf copr enable zeno/scrcpy
sudo dnf install scrcpy

For Debian/Ubuntu, avoid the default repository version. Instead, use the install script method described next. The packaged version lacks audio forwarding and modern codec support, severely limiting functionality.

Automated Install Script

The project provides install_release.sh, which automates downloading and installing the latest release. This script handles dependencies, fetches the prebuilt server binary, and compiles the client from source for optimal performance.

First, install dependencies:

# Debian/Ubuntu
sudo apt install ffmpeg libsdl2-2.0-0 adb wget gcc git pkg-config meson ninja-build libsdl2-dev libavcodec-dev libavdevice-dev libavformat-dev libavutil-dev libswresample-dev libusb-1.0-0 libusb-1.0-0-dev

# Fedora
sudo dnf install SDL2-devel ffms2-devel libusb1-devel libavdevice-free-devel meson gcc make java-devel

Then clone and install:

git clone https://github.com/Genymobile/scrcpy
cd scrcpy
./install_release.sh

The script creates a build-auto directory, configures Meson, downloads the server JAR, and installs to /usr/local. To update later:

git pull
./install_release.sh

This method gives you the latest features while maintaining system integration. It's the recommended approach for Linux users who want both convenience and current functionality.

Building from Source

Building from source is straightforward but rarely necessary for end users. The process involves cloning the repository, installing development dependencies, and running Meson. The main reason to build manually is to test the development branch or apply custom patches.

The build system requires Java 17+ for the server component and Meson/Ninja for the client. The server is a small Java application that runs on the device; the client is a C application that uses FFmpeg and SDL2. The build process compiles both, though you can use a prebuilt server to skip Java dependencies.

Windows Installation

Windows installation prioritizes simplicity. The official release is a zip archive containing everything needed. Package managers offer alternative installation paths.

Official Release Package

Download scrcpy-win64-v3.3.4.zip from the releases page. Extract it to a permanent location—C:\Tools\scrcpy works well. The archive contains:

• scrcpy.exe (main application)
• adb.exe (Android Debug Bridge)
• scrcpy-server (server binary)
• DLL files for FFmpeg and SDL2
• Batch files for easy launching

Unlike Linux, Windows doesn't require separate ADB installation. The included adb.exe works because the current directory is implicitly in PATH when running from the extracted folder.

To run scrcpy, open a command prompt in the extracted directory. The release includes open_a_terminal_here.bat for convenience. Double-click it, then type:

scrcpy

For regular use, add the directory to your system PATH. Open System Properties → Environment Variables → System Variables → PATH, and add C:\Tools\scrcpy. This lets you run scrcpy from any terminal.

Package Manager Installation

Modern Windows supports multiple package managers. WinGet, included in Windows 10/11, provides the smoothest experience:

winget install --exact Genymobile.scrcpy

This command installs scrcpy, ADB, and all dependencies automatically. The package comes from the official repository, ensuring authenticity.

Chocolatey users can run:

choco install scrcpy
choco install adb

Scoop offers a similar experience:

scoop install scrcpy
scoop install adb

Package managers handle updates automatically. When a new scrcpy version releases, winget upgrade Genymobile.scrcpy fetches and installs it. This convenience comes at the cost of slight delay—packages may lag the GitHub release by days or weeks.

ADB Driver Considerations

Windows often requires USB drivers for proper device detection. Google provides a universal driver for Nexus and Pixel devices. OEMs like Samsung, OnePlus, and Xiaomi offer their own drivers. If adb devices shows no devices despite proper cable and device settings, install the appropriate driver.

The driver installation process varies. For Google devices, download the Android USB Driver from the developer site, then use Device Manager to update the driver for your phone. Point it to the extracted driver folder. For other devices, check the manufacturer's developer site. Some phones require special modes—Samsung needs "File Transfer" mode enabled, not just charging.

macOS Installation

macOS installation mirrors Linux in simplicity but has platform-specific considerations. The official static build works on both Intel and Apple Silicon Macs.

Official Static Build

Download either scrcpy-macos-aarch64-v3.3.4.tar.gz (Apple Silicon) or scrcpy-macos-x86_64-v3.3.4.tar.gz (Intel). Extract the archive:

tar -xzf scrcpy-macos-aarch64-v3.3.4.tar.gz
cd scrcpy-macos-aarch64-v3.3.4
./scrcpy

macOS may block execution with a security warning. Open System Preferences → Security & Privacy → General, and click "Allow Anyway" next to the scrcpy warning. This only happens on first run.

The static build includes all dependencies except ADB. Install it via Homebrew:

brew install android-platform-tools

Or download the platform-tools package from Google and add it to your PATH in .zshrc or .bash_profile.

Homebrew Installation

Homebrew provides the most integrated macOS experience:

brew install scrcpy
brew install --cask android-platform-tools

The first command installs scrcpy and its runtime dependencies. The second installs ADB and related tools as a cask. Homebrew manages updates automatically—brew upgrade scrcpy fetches the latest version.

Homebrew's version may lag slightly behind GitHub releases, but it offers better system integration. The formula includes shell completions and man pages, which static builds require manual installation of.

MacPorts Installation

MacPorts offers an alternative for users who prefer its ecosystem:

sudo port install scrcpy

MacPorts handles ADB automatically as a dependency. The installation path differs from Homebrew—typically /opt/local/bin/scrcpy. Ensure this directory is in your PATH.

MacPorts builds from source, which takes longer but ensures compatibility with your specific macOS version. This can be advantageous when running older macOS releases that Homebrew no longer supports.

First Launch and Verification

With installation complete, it's time for the moment of truth. The first launch verifies everything works and introduces basic usage patterns.

USB Connection Verification

Connect your Android device via USB. Run adb devices to confirm detection. If you see your device listed as "device" (not "unauthorized"), you're ready.

Launch scrcpy without arguments:

scrcpy

The client pushes the server to your device, starts it, and opens a window showing your phone screen. The first launch takes slightly longer—perhaps two seconds—as it establishes the initial connection and caches the server binary. Subsequent launches typically complete in under a second.

You should see your device screen mirrored in real-time. Try interacting with it:

• Click on the scrcpy window to focus it
• Move your mouse; the device cursor should follow
• Click; it registers as a touch
• Type on your keyboard; text appears in the active input field

Basic Control Verification

Test essential controls to confirm full functionality:

• Right-click anywhere; this triggers BACK by default
• Middle-click; this triggers HOME
• Press Alt+F; this toggles fullscreen mode
• Copy text on your computer (Ctrl+C), then paste on the device (Ctrl+V in a text field)

If these operations work, your installation is successful. If not, revisit the prerequisites section—most issues stem from missing USB debugging security settings or ADB authorization problems.

Resolution and Performance Tuning

The default settings prioritize quality over performance. For smoother operation, especially on older hardware, reduce the resolution:

scrcpy -m1024

This limits the video stream to 1024 pixels on the longest edge, dramatically reducing CPU load. The -m flag is shorthand for --max-size. Values between 800 and 1280 work well for most use cases.

If you notice lag, check your terminal output. Scrcpy prints encoder information and connection details. Look for lines like:

INFO: Initial texture: 1080x2400
INFO: FPS counter started

The FPS counter appears when you enable it with --fps-start=10 (shows FPS after 10 seconds). This helps diagnose performance bottlenecks.

Wireless Connection Quick Test

Once USB works, test wireless connectivity. This requires Android 11+ or manual ADB TCP/IP setup. For modern devices:

scrcpy --tcpip

This command automatically finds your device's IP, enables TCP/IP mode, and connects. You'll see the same mirroring window, now without a USB cable. The connection uses your local network, so both devices must share the same Wi-Fi.

For older devices, first enable TCP/IP manually:

adb tcpip 5555
adb connect 192.168.1.100:5555  # Replace with your device's IP
scrcpy

Wireless connections introduce slight latency—typically 5-10ms more than USB—but offer freedom of movement. The performance remains excellent for most tasks, though competitive gaming might prefer the USB connection's minimal latency.

Recording Your First Session

Scrcpy can record your screen to a video file. Try:

scrcpy --record=first-test.mp4

Interact with your device for a minute, then close the scrcpy window. The recording saves automatically. Play it back with any video player. The file uses H.264 video and AAC audio by default, ensuring broad compatibility.

For higher quality, use H.265:

scrcpy --record=first-test.mp4 --video-codec=h265

Note that H.265 requires device support. If the encoder fails, scrcpy falls back to H.264 automatically.

Troubleshooting First Launch Issues

If scrcpy fails to start, the error messages are usually descriptive. Common scenarios include:

"ERROR: Could not find any ADB device"

• ADB can't see your device. Run adb devices to verify. Check cables, drivers, and USB debugging settings.

"ERROR: Device is unauthorized"

• The authorization popup was dismissed. Disconnect and reconnect USB, then accept the popup.

"ERROR: Multiple ADB devices"

• You have more than one device connected. Specify which to use: scrcpy -s 0123456789abcdef using your device's serial.

"adb server version doesn't match this client"

• Multiple ADB versions are running. Close Android Studio, kill the ADB server with adb kill-server, then try again.

The terminal output is your best diagnostic tool. Scrcpy prints each step of the connection process. Reading these messages often reveals the exact problem without needing external documentation.

Integration with Workflow

Now that scrcpy works, consider how it fits into your daily workflow. For developers, keep a terminal open in your project directory and launch scrcpy with device-specific scripts. For example, create dev-phone.sh:

#!/bin/bash
scrcpy --turn-screen-off --stay-awake --max-size=1600

This script turns off the device screen while mirroring (saving battery), prevents the device from sleeping during development, and sets a reasonable resolution. Make it executable with chmod +x dev-phone.sh and run it whenever you start a development session.

For content creators, create recording scripts with specific quality settings:

#!/bin/bash
scrcpy --record=tutorial-$(date +%Y%m%d-%H%M%S).mp4 --max-fps=30 --video-codec=h265

This timestamps your recordings automatically and ensures consistent frame rates.

Next Steps and Exploration

With installation verified and basic usage understood, the real exploration begins. The scrcpy command accepts dozens of options controlling everything from video bitrate to keyboard injection methods. The built-in help provides a comprehensive reference:

scrcpy --help

This outputs all available options with brief descriptions. It's worth skimming to understand the tool's breadth. Key areas to explore next include:

• Video quality tuning for different network conditions
• Audio forwarding for Android 11+ devices
• Physical keyboard simulation modes for better text input
• OTG mode for controlling devices without screen mirroring
• Virtual displays for running apps in isolated environments

Each feature builds on the solid foundation you've just established. The installation process, while requiring attention to prerequisites, ensures that when scrcpy runs, it runs reliably. The time invested in proper setup pays dividends in frustration avoided later.

The journey from installation to mastery involves understanding these options not as isolated features but as a cohesive system for device interaction. Scrcpy's design philosophy—lightweight, performant, non-intrusive—becomes more apparent as you delve deeper. The tool respects your device's resources, your network bandwidth, and your privacy. It doesn't phone home, show ads, or demand accounts. It's simply a bridge between your computer and Android device, built by developers who understood that the best tools are the ones that get out of your way.

As we transition to the next chapter, we'll explore the nuances of device connection—both USB and wireless—and master the basic controls that make scrcpy an indispensable part of the Android development and usage workflow. The foundation is set; now we build upon it.