Title: The Ghost in the Glass
Maya was a debugger. Not the kind with a magnifying glass, but the kind who chased phantom bugs through layers of code. Her weapon of choice? ws-scrcpy.
It was 3:00 AM. A server farm in Virginia was throwing kernel panics, but the only physical access she had was a dusty Android tablet taped to a rack. It ran the logging interface.
She couldn't drive two hours to the data center. She could, however, open her laptop.
A few keystrokes later, the browser window flickered. Then, like a mirror into another room, the tablet's home screen appeared on her screen. High-res. Low latency. She wiggled her mouse, and a phantom finger swiped left on the distant device. Ws-scrcpy didn't just mirror—it breathed.
Maya dragged a file from her local drive—a patched firmware binary—and dropped it onto the virtual screen. The browser’s WebSocket hummed. 2,000 miles away, the tablet’s file explorer opened and accepted the drop.
“Come on,” she whispered.
She opened a terminal on the tablet (thanks to the built-in shell access of ws-scrcpy) and typed:
fastboot flash boot patched.img
The server’s heartbeat resumed. Pings returned.
But then—she noticed something odd.
The tablet’s screen, usually static, was moving on its own. A ghost tap. A swipe. The Settings app opened, then closed. Then the camera.
Maya hadn’t touched her mouse.
She stared at the ws-scrcpy interface. It showed 1 active viewer.
Herself.
She refreshed the page. The counter dropped to zero, then climbed back up to… 2.
Her pulse hammered. Someone else was inside the same WebSocket tunnel. A shadow viewer. No authentication logs. No IP trail.
She couldn't close the connection—if she did, she’d lose the ability to patch the server. But if she stayed, the ghost would see everything.
Then she remembered: ws-scrcpy had a hidden feature. A console command: --lock-device.
She opened the developer tools, injected a raw WebSocket frame, and sent:
"type": "lock", "force": true
The tablet’s screen went black. The ghost’s cursor vanished. ws-scrcpy
Silence.
Maya finished the patch. Rebooted the server. Then, slowly, she unlocked the device.
The camera feed was on. And in the grainy preview, reflected in the tablet’s own glass, she saw a figure standing in the empty data center—shoulder to shoulder with the rack.
But the data center had been locked for hours.
She closed the browser. Killed the power to the tablet remotely.
The next morning, security footage showed no intruder. Just a tablet, screen cracked, lying face-down on the floor.
And a single line in the ws-scrcpy logs:
"Session 0x7F3A: Unknown origin. Low latency. High fright."
Maya never used ws-scrcpy alone again. But she never stopped watching the viewer count.
ws-scrcpy is a web-based version of the popular open-source tool scrcpy, which allows you to view and control Android devices from a desktop. While the original scrcpy is a standalone application, ws-scrcpy uses WebSockets to bring that same functionality directly into your web browser. Key Features
Browser-Based Control: Mirror and control your device via Chrome, Firefox, or other modern browsers without needing to install the scrcpy client software on every machine.
Flexible Video Decoding: It includes multiple player options for different browser capabilities, such as Mse Player (HTML5 Video), Broadway Player (WebAssembly), and WebCodecs Player (hardware-accelerated decoding in Chromium).
Full Interaction: Supports touch events, multi-touch emulation (using CTRL/SHIFT), mouse wheel scrolling, and keyboard event capturing.
Remote Management: Features include a remote shell (adb shell in-browser), file listing/downloading, and the ability to drag and drop APKs to push them to the device.
Shared Clipboard: Supports bidirectional copy-pasting between your computer and the Android device. How It Works Backend: A Node.js server runs on your host computer.
Connection: This server detects connected Android devices via ADB (USB or TCP/IP) and deploys a modified scrcpy-server.jar to them.
Streaming: The device streams H.264 video to the Node.js server, which then relays it to your browser via WebSockets. Installation & Setup scrcpy/doc/connection.md at master - GitHub
is a web-based client prototype for , the popular open-source tool for mirroring and controlling Android devices from a computer. Unlike the standard version that runs as a desktop application,
allows you to view and control your phone directly through a web browser using WebSockets. Key Features Browser-Based Control
: Mirror your screen and use touch events, keyboard input, and mouse/touchpad scrolling without a dedicated desktop client. Multiple Players : Supports several video decoders including (for Chrome/Chromium), File Management
: Supports dragging and dropping APKs for installation, file pushing, and browsing device files. Remote Shell : Access a remote shell directly from your browser. Device Interaction Title: The Ghost in the Glass Maya was a debugger
: Supports device rotation, multi-touch emulation, and clipboard sharing between the device and computer. Prerequisites Android Device : Must be running Android 5.0 (API 21) or higher. USB Debugging : You must enable Developer Options and turn on USB Debugging on your Android device. Server Environment : Requires a server (often
) to handle the WebSocket communication between the browser and the device. Quick Setup Steps Prepare the Phone Settings > About Phone and tap the Build Number seven times to unlock Developer Options. Enable USB Debugging Install Node.js & ws-scrcpy : Download the ws-scrcpy repository and install dependencies using npm install Run the Server : Start the server using the provided commands (usually or building from source). Connect via Browser
: Open your browser and navigate to the local address (typically
is a web-based client prototype for , allowing you to display and control Android devices directly through a web browser. It functions by running a Node.js server that communicates with a modified version of the scrcpy-server.jar on the Android device via WebSockets. Key Features Browser-Based Mirroring : View your Android screen in a browser using decoders like Mse Player Remote Control
: Perform touch events (including multi-touch), keyboard inputs, and mouse wheel scrolling remotely. Device Management
: Includes basic file listing, drag-and-drop APK installation, and a remote shell through Limited iOS Support : Can track and control iOS devices if WebDriverAgent are configured. Security Considerations
There are significant security trade-offs to keep in mind when using ws-scrcpy: No Encryption
: By default, there is no encryption between the browser and the Node.js server or the Android device. No Authorization
: There is no built-in level of authorization for connecting to the server. Modified scrcpy
: The modified server remains running even after the last client disconnects and listens on all network interfaces. Deployment and Status Installation : Requires Node.js and can be set up by cloning the ws-scrcpy GitHub repository , installing dependencies with npm install , and starting with Docker Support
: While the official project does not include a Dockerfile, community forks like n1n3b1t's 2025 update have added Docker support and other modern updates. Current State
: As of 2025, the original maintainers are no longer actively developing the project, though the community continues to provide forks and updates for newer scrcpy versions. Updated ws-scrcpy with docker, and few updated for 2025
WS-SCRCPY is an open-source web-based prototype designed to extend the capabilities of the popular scrcpy tool, allowing users to mirror and control Android devices directly through a web browser. While the original scrcpy by Genymobile is a high-performance desktop application, ws-scrcpy leverages WebSockets to provide a similar experience without requiring a native client on the viewing machine. Core Features of WS-SCRCPY
The primary appeal of ws-scrcpy is its accessibility and cross-platform flexibility.
Browser-Based Mirroring: Stream your Android screen as H.264 video directly to any modern browser.
Full Remote Control: Use your computer's mouse and keyboard to interact with the device. This includes multi-touch emulation (using CTRL or SHIFT keys) and scroll support.
Multi-Device Management: Connect and switch between multiple Android devices from a single web interface.
Advanced File Handling: Drag-and-drop support for pushing APKs or other files to the device's storage.
Remote Shell Access: Open an ADB shell directly in the browser using an integrated xterm.js terminal emulator.
Configurable Quality: Adjust video quality, bitrate, and resolution to optimize performance for different network conditions. How WS-SCRCPY Works
Unlike standard scrcpy, which uses a direct USB or TCP/IP connection to a desktop binary, ws-scrcpy acts as a bridge. It runs a Node.js server that communicates with a modified version of the scrcpy-server on the Android device. The server converts the device's video stream and input events into WebSockets, which the browser can then interpret in real-time. Installation and Setup "Session 0x7F3A: Unknown origin
To get started with ws-scrcpy, you typically need to set up the server environment on a host computer (Windows, macOS, or Linux) that has the Android device connected via USB or accessible over the same Wi-Fi network. Prerequisites:
Ensure USB Debugging is enabled in your Android device's "Developer Options".
Install Node.js and ADB (Android Debug Bridge) on your host computer. Server Setup:
Download the latest release from the ws-scrcpy GitHub repository.
Install dependencies and build the project (often using npm install and npm run build or npm start).
Recent community updates have also introduced Docker support, making it easier to deploy in containerized environments like Unraid or home servers. Accessing the Device:
Once the server is running, open your browser and navigate to the local address (usually http://localhost:8000).
Select your connected device from the list to begin the mirroring session. Comparison: WS-SCRCPY vs. Standard SCRCPY
NetrisTV/ws-scrcpy: Web client prototype for scrcpy. - GitHub
Record MP4 videos of your screen interactions or capture PNG screenshots with one click. The files are saved to your local drive via the browser.
# Install
npm install -g ws-scrcpy
Beyond USB Cables: The Ultimate Guide to ws-scrcpy – Web-Based Remote Control for Android
In the world of Android development and device management, scrcpy (Screen Copy) has long been the gold standard for low-latency, high-performance display and control. However, a powerful evolution of this tool has emerged to solve one of its biggest limitations: the physical USB tether.
Enter ws-scrcpy. This tool takes the core engine of the classic scrcpy and wraps it in a WebSocket server, allowing you to control Android devices from any modern web browser—over a local network or even the internet.
If you manage multiple test devices, provide remote support, or simply want to project your phone onto your office PC without installing drivers, this guide is for you.
7. Security & Hardening
Running ws-scrcpy exposes a direct control interface to your phone. Do not expose port 8000 directly to the internet without precautions.
Method A: Docker (Recommended for Stability)
Docker is the easiest way to run ws-scrcpy because it bundles Node.js, dependencies, and often the ADB binaries into an isolated environment.
-
Pull the image:
docker pull netris/ws-scrcpy
-
Run the container:
You must mount the ADB device connection into the container.
docker run -d \
--name ws-scrcpy \
-p 8000:8000 \
-v /dev/bus/usb:/dev/bus/usb \
--privileged \
netris/ws-scrcpy
- Note on Privileged Mode: This is required to access the raw USB devices for ADB. If you are on Linux and want tighter security, you can mount specific device paths, but
--privileged is the most reliable method for USB connected phones.
-
Access the UI:
Open your browser to http://localhost:8000.
Running with Docker (Easiest for Linux Servers)
docker run -it --rm \
--device /dev/bus/usb \
-p 8000:8000 \
--name ws-scrcpy \
ghcr.io/totvs/ws-scrcpy:latest
1. Multi-Device Grid View
If you have 10 Android phones plugged into a USB hub, ws-scrcpy displays all of them in a responsive HTML grid. You can click any device to focus, type, or swipe.