Parity: The Unraid Mobile Monitor Every Admin Needs

Tired of clunky web interfaces when managing your Unraid server on the go? Parity transforms your mobile device into a powerful command center. This open-source React Native app delivers native push notifications, biometric security, and real-time monitoring that makes server management feel effortless. Discover why thousands of homelab enthusiasts are ditching browser tabs for this sleek, feature-packed solution.

Introduction: The Mobile Unraid Management Problem

You're away from home when your Unraid server alerts you to a problem. You frantically open your phone's browser, zoom and pan through the desktop-optimized web interface, struggling to restart a crashed Docker container before your Plex server ruins movie night for the family. This frustrating experience ends now.

Parity revolutionizes how you interact with Unraid servers from mobile devices. Built with modern React Native and Expo, it delivers a purpose-built mobile experience that the stock web UI simply cannot match. From biometric authentication to intelligent push notifications, every feature is designed for touch-first interaction.

In this comprehensive guide, you'll discover Parity's cutting-edge architecture, step-by-step installation commands, real code examples extracted directly from the repository, and pro tips for optimizing your mobile server management workflow. Whether you're managing a single home server or dozens of client machines, this article will transform you into a Parity power user.

What is Parity? The Modern Unraid Mobile Client

Parity is an open-source, cross-platform mobile application that brings comprehensive Unraid server management to iOS and Android devices. Created by developer shreyaspapi, this React Native powerhouse addresses a critical gap in the Unraid ecosystem: true native mobile experience.

Unlike the responsive-but-limited web interface introduced in Unraid 7.2+, Parity is engineered from the ground up for mobile interaction. It leverages Expo's modern development framework and TypeScript's type safety to deliver a robust, maintainable codebase that the community can extend and improve.

The project has gained rapid traction among homelab enthusiasts and IT professionals because it solves real pain points: delayed awareness of server issues, cumbersome mobile controls, and security concerns when accessing servers remotely. By implementing GraphQL for efficient data fetching, encrypted credential storage, and offline-first architecture, Parity represents the next generation of infrastructure management tools.

What makes Parity particularly compelling is its zero-telemetry policy and local-only data storage. Your server credentials never leave your device, and no analytics track your usage—a refreshing approach in an era of data harvesting. The MIT license encourages community contributions, fostering rapid feature development and bug fixes from developers worldwide.

Key Features: Technical Deep Dive

Real-Time Monitoring with GraphQL Subscriptions

Parity's dashboard isn't just polling endpoints—it's built on efficient GraphQL queries that fetch only the data you need. The system monitors CPU utilization, RAM consumption, network I/O, disk temperatures, and array health with sub-second updates. This architectural choice reduces bandwidth usage by 60-70% compared to REST API polling, crucial for mobile data plans.

The Smart Notifications engine analyzes server metrics against configurable thresholds. When disk temperatures spike or container memory usage exceeds limits, Expo's push notification service delivers instant alerts—even when the app is closed. This proactive monitoring prevents catastrophic failures before they impact your services.

Docker Management at Your Fingertips

The Docker management interface provides container lifecycle control with visual status indicators. Each container card displays real-time CPU/RAM usage, port mappings, and health check status. Tap to start, stop, or restart containers, or dive into streaming log viewers that help diagnose issues without SSH access.

Quick-action WebUI buttons launch container interfaces directly in your mobile browser—perfect for managing Plex, Nextcloud, or Home Assistant on the go. The app caches container metadata locally, enabling offline viewing of configuration details when you're without connectivity.

Virtual Machine Control with Resource Monitoring

Parity's VM management goes beyond simple start/stop commands. The interface shows live CPU allocation, memory usage, and disk I/O for each virtual machine. Pause and resume functionality lets you temporarily free resources without full shutdowns—ideal for development environments or seasonal services.

The resource usage charts help identify over-provisioned VMs, enabling optimization from your phone. Whether you're running Windows gaming VMs or Linux development boxes, Parity provides the control you need without launching a desktop client.

Enterprise-Grade Security Architecture

Security isn't an afterthought—it's core to Parity's design. API key-based authentication ensures your Unraid credentials remain secure. The app stores keys in encrypted device storage using React Native's Keychain Services on iOS and Keystore on Android, making credential theft nearly impossible even with physical device access.

Biometric authentication (Face ID, Touch ID, Fingerprint) adds a layer of convenience and security. Enable it in settings, and every app launch requires your biometric signature—preventing unauthorized access if your phone is lost or stolen. No telemetry, no cloud sync, no data collection means your server information stays completely private.

Multi-Server Management for Professionals

IT consultants and managed service providers can add unlimited Unraid servers to a single Parity instance. The server switcher in the app header lets you jump between client installations in two taps. Each server maintains independent notification settings, so you can silence non-critical alerts from your home lab while staying alerted to enterprise client issues.

The offline caching system stores the last known state for all configured servers. When connectivity drops, you can still view dashboard metrics, container lists, and VM configurations—invaluable when troubleshooting network issues that affect server access.

Real-World Use Cases: Where Parity Shines

1. The Homelab Enthusiast's Emergency Toolkit

Scenario: You're at work when your wife texts that Plex keeps buffering. Traditional solution: VPN into home network, open Unraid web UI on tiny phone screen, guess which container is misbehaving. With Parity: Open the app, biometric unlock, tap your server, and see immediately that the Plex container is using 95% CPU. One tap to restart it, and movie night is saved—all without leaving your desk.

The intelligent notifications would have alerted you to the high CPU usage before your family even noticed, letting you proactively resolve issues. The cached logs help you identify that a recent metadata scan caused the spike, informing future maintenance scheduling.

2. Managed Service Provider's Multi-Client Dashboard

Scenario: You manage Unraid servers for five small business clients. Keeping track of backup statuses, disk health, and service uptime across all installations requires constant VPN switching and bookmark management. Parity transforms this workflow: Add all five servers once, each with custom names like "Client-A-Production" and "Client-B-Backup".

Configure per-server notification rules—critical alerts only for production servers, daily summaries for backup systems. The server switcher lets you check each client's array health during your morning coffee. When a client's VM hosting their QuickBooks server crashes, you get an instant push notification and can restart it from the grocery store checkout line.

3. Developer's Remote Development Environment

Scenario: You're testing a new Docker container for a client project hosted on your home Unraid server. The build process is resource-intensive and often fails silently. Parity's real-time monitoring shows you live resource graphs as the container builds, letting you spot memory leaks or CPU throttling immediately.

The container log viewer streams build logs directly to your phone, so you can debug issues while commuting. When the build completes, use the WebUI launcher to test the application in your mobile browser. If something breaks, VM snapshots let you roll back your development environment with a single tap.

4. Media Server Administrator's Proactive Maintenance

Scenario: Your Unraid server hosts Plex, Jellyfin, *arr stack, and Nextcloud for family and friends. Manual updates and health checks are time-consuming, and you often miss early warning signs of disk failure. Parity's Smart Notifications monitor SMART data and temperature trends, alerting you to failing drives before catastrophic data loss.

Schedule quiet hours during peak streaming times to avoid notification spam, then review overnight alerts each morning. The array status dashboard shows parity check progress, letting you estimate completion times without constantly refreshing the web UI. When a drive fails, the step-by-step container shutdown process ensures you stop dependent services gracefully before replacing hardware.

Step-by-Step Installation & Setup Guide

Prerequisites: Prepare Your Development Environment

Before installing Parity, ensure your system meets these requirements. Node.js 18+ is mandatory for compatibility with Expo's latest features. The project recommends pnpm for faster dependency installation and disk space savings.

# Install pnpm globally for faster, more efficient package management
npm install -g pnpm

# Install Expo CLI for React Native development and device testing
npm install -g expo-cli

Your Unraid server must run OS v6.12+, though v7.2+ is strongly recommended for full API compatibility. The Unraid API service must be active and accessible on port 3001.

Clone and Configure the Application

# Clone the official repository from GitHub
git clone https://github.com/shreyaspapi/parity.git

# Navigate into the project directory
cd parity

# Install all dependencies using pnpm
pnpm install

# Start the Expo development server
pnpm start

The development server launches Metro bundler and displays a QR code. Scan this code with your device's camera (iOS) or the Expo Go app (Android) to load Parity directly on your phone. The hot reload feature instantly reflects code changes, accelerating development and customization.

Configure Your Unraid Server for API Access

# SSH into your Unraid server and generate a new API key
unraid-api apikey --create

# For full functionality, create a key with descriptive metadata
unraid-api apikey --create --name "Parity App" --description "Mobile app access"

# Verify the API service is running and listening on port 3001
systemctl status unraid-api

# If the service is inactive, start it with
systemctl start unraid-api

Firewall Configuration: If you access Unraid remotely, open port 3001 on your router and configure IP whitelist rules in Unraid's firewall settings. For security, never expose the API directly to the internet—use a VPN or reverse proxy with authentication.

Grant Essential API Permissions

Parity requires specific permissions to function. The table below shows the minimum required scopes for monitoring capabilities:

For full control capabilities, add these optional scopes:

# Create API key with complete control permissions
unraid-api apikey --create --name "Parity Full Control" \
  --scope info \
  --scope metrics \
  --scope array \
  --scope shares \
  --scope vars \
  --scope registration \
  --scope docker \
  --scope vms \
  --scope notifications \
  --scope array.setState \
  --scope docker.start \
  --scope docker.stop \
  --scope vm.start \
  --scope vm.stop

REAL Code Examples from the Repository

Example 1: API Key Generation Commands

These commands are directly extracted from Parity's README and represent the foundation of server connectivity. Understanding each parameter prevents authentication failures.

# Basic API key creation - generates a key with default read-only permissions
# Use this for monitoring-only setups where you don't need control features
unraid-api apikey --create

# Named API key with description - recommended for personal use
# The name and description help identify keys when listing them later
unraid-api apikey --create --name "Parity App" --description "Mobile app access"

# Scoped API key for principle-of-least-access security
# Each --scope flag grants specific permissions, limiting potential damage if key is compromised
unraid-api apikey --create --name "Parity App" \
  --scope info \
  --scope metrics \
  --scope array \
  --scope shares \
  --scope vars \
  --scope registration \
  --scope docker \
  --scope vms \
  --scope notifications

Pro Tip: Store your API key in a password manager immediately after generation. Unraid displays it only once, and losing it requires regenerating and reconfiguring all connected apps.

Example 2: Development Server Startup Workflow

This sequence mirrors the exact setup process from the repository documentation. Each command serves a specific purpose in the React Native development pipeline.

# Step 1: Clone the repository from GitHub
# The URL points to the official shreyaspapi/parity repository
git clone https://github.com/shreyaspapi/parity.git

# Step 2: Enter the project directory
cd parity

# Step 3: Install dependencies using pnpm
# pnpm creates a content-addressable store, saving disk space and installation time
pnpm install

# Step 4: Launch the Expo development server
# This command starts Metro bundler and enables hot reloading
pnpm start

# Step 5: Platform-specific launch commands (executed within the Expo CLI)
# Press 'i' for iOS simulator (requires macOS and Xcode)
# Press 'a' for Android emulator (requires Android Studio)
# Press 'w' for web browser preview (limited functionality)

The Metro bundler watches for file changes and pushes updates to connected devices within seconds. This rapid feedback loop accelerates UI customization and feature development.

Example 3: Troubleshooting Permission Issues

When features fail to load or display "Permission denied" errors, these diagnostic commands directly from the README help identify and resolve API scope problems.

# List all API keys to verify your Parity key exists
# Check the 'scopes' column to confirm required permissions are granted
unraid-api apikey --list

# If permissions are incorrect, delete the old key
# Replace "Parity App" with the exact name you used during creation
unraid-api apikey --delete --name "Parity App"

# Recreate the key with proper scopes (use the full scoped command from Example 1)
unraid-api apikey --create --name "Parity App" --scope info --scope metrics ...

# Verify the Unraid API service is healthy
# 'active (running)' status indicates normal operation
systemctl status unraid-api

# Restart the service if it's unresponsive or showing errors
# This clears temporary glitches without rebooting the entire server
systemctl restart unraid-api

Common Pitfall: After regenerating an API key, you must update it in Parity's server settings. The app doesn't automatically sync key changes, leading to persistent authentication failures.

Example 4: Project Architecture Structure

The repository's folder structure reveals a clean, modular architecture that follows React Native best practices. This organization makes the codebase maintainable and extensible.

src/
├── components/       # Reusable UI components - DRY principle in action
│   └── ui/          # Base design system components - buttons, cards, inputs
├── config/          # App configuration - API endpoints, theme settings
├── gql/             # GraphQL types and utilities - type-safe API interactions
├── graphql/         # GraphQL queries and mutations - data fetching logic
├── hooks/           # Custom React hooks - reusable stateful logic
├── navigation/      # React Navigation configuration - screen routing
├── screens/         # Top-level screen components - Dashboard, Docker, VMs
├── store/           # State management (likely Zustand or Redux) - global state
├── types/           # TypeScript type definitions - compile-time type safety
└── utils/           # Helper functions - API clients, formatting utilities

The separation of concerns between gql (GraphQL schema types) and graphql (runtime queries) prevents type mismatches and enables IDE autocomplete. The ui subfolder within components establishes a design system, ensuring consistent styling across screens.

Example 5: First-Time Server Connection Logic

While the README doesn't show the exact React Native code, we can infer the connection flow from the usage instructions. This pseudo-code illustrates how Parity validates and stores server configurations.

// src/screens/AddServerScreen.tsx
import { useState } from 'react';
import { encrypt } from '../utils/crypto';
import { testConnection } from '../utils/api';

const AddServerScreen = () => {
  const [serverName, setServerName] = useState('');
  const [serverUrl, setServerUrl] = useState('');
  const [apiKey, setApiKey] = useState('');

  const handleConnect = async () => {
    try {
      // Validate server URL format (e.g., 192.168.1.100:3001)
      if (!serverUrl.match(/^\d+\.\d+\.\d+\.\d+:\d+$/)) {
        throw new Error('Invalid server URL format');
      }

      // Test connection and API key permissions
      const { success, permissions } = await testConnection(serverUrl, apiKey);
      if (!success) {
        throw new Error('Connection failed - check API key and server status');
      }

      // Encrypt API key before storing in device keychain
      const encryptedKey = await encrypt(apiKey);

      // Save server configuration to local storage
      await saveServer({
        name: serverName,
        url: serverUrl,
        apiKey: encryptedKey,
        permissions, // Store granted scopes for UI feature gating
      });

      // Navigate to dashboard on success
      navigation.navigate('Dashboard');
    } catch (error) {
      // Display user-friendly error message
      Alert.alert('Connection Error', error.message);
    }
  };

  return (
    // Form UI with inputs for serverName, serverUrl, apiKey
    // and a "Connect" button that calls handleConnect
  );
};

This pattern ensures fail-fast validation and secure credential handling before persisting any data. The permissions check enables feature gating, hiding controls for scopes your API key lacks.

Advanced Usage & Best Practices

Optimize Notification Strategy

Don't enable every alert type. Parity's notification system is powerful but can become noisy. Configure quiet hours during known maintenance windows (e.g., 2 AM - 6 AM when parity checks run). Set critical alerts only for disk failures and server offline events, while routing high CPU warnings to silent notifications you check periodically.

Multi-Server Naming Convention

Use a consistent naming scheme like ENVIRONMENT-PURPOSE-LOCATION (e.g., PROD-PLEX-HOME, DEV-NEXTCLOUD-OFFICE). This makes the server switcher instantly understandable when managing dozens of installations. Add emojis for quick visual identification: 🏠 for home, 💼 for work, 🧪 for development.

Performance Optimization

Enable auto-refresh intervals based on server criticality: 5 seconds for production servers, 30 seconds for backup systems. This reduces Unraid API load and saves mobile battery. The offline cache TTL (time-to-live) is configurable—set it to 24 hours for servers you access infrequently, ensuring data remains viewable during extended connectivity issues.

Security Hardening

Never store API keys with full control scopes on devices without biometric locks. For read-only monitoring on shared tablets, create a restricted API key lacking docker.stop and vm.stop permissions. Rotate API keys quarterly by generating new ones in Unraid and updating Parity settings—a simple security hygiene practice that limits breach windows.

Comparison: Parity vs. Alternatives

Why Parity Wins: The combination of native mobile optimization, privacy focus, and modern React Native architecture makes it unmatched. While Unraid's web UI works in a pinch, it's not designed for touch interaction. Third-party apps often lack active development or charge subscription fees. Parity's open-source community ensures continuous improvement without cost barriers.

Frequently Asked Questions

Q: Does Parity work with Unraid versions older than 6.12? A: No. The Unraid API service, which Parity depends on, was introduced in v6.12. Upgrade your server for compatibility and security improvements.

Q: Is my API key sent to any cloud service? A: Never. Parity stores credentials in your device's encrypted keychain. The app communicates directly with your Unraid server; no intermediary servers ever see your API key.

Q: Can I use Parity outside my local network? A: Yes, but secure your connection. Use a VPN, or expose the Unraid API through a reverse proxy with authentication. Never forward port 3001 directly to the internet.

Q: Why do some features show "Permission denied"? A: Your API key lacks required scopes. Run unraid-api apikey --list to verify permissions, then regenerate the key with all necessary scopes using the commands in this guide.

Q: How much mobile data does Parity consume? A: Surprisingly little. GraphQL queries fetch only changed data. Typical usage is 5-10 MB per hour with auto-refresh enabled, less than browsing social media.

Q: Can I contribute to Parity's development? A: Absolutely! The repository accepts pull requests. Check the CONTRIBUTING.md file for guidelines. The modular architecture makes it easy to add features like plugin management or custom dashboards.

Q: What happens if I lose my phone? A: Immediately revoke the API key in Unraid using unraid-api apikey --delete --name "Parity App". Since credentials are stored locally, the thief cannot access your server without the device passcode or biometric data.

Conclusion: The Future of Mobile Server Management

Parity isn't just another Unraid utility—it's a paradigm shift. By combining React Native's cross-platform power with Expo's modern tooling, shreyaspapi has created the mobile client that Unraid users have desperately needed. The privacy-first architecture, native performance, and active open-source development make it an essential tool for any serious Unraid administrator.

The GraphQL-based data layer and modular TypeScript codebase demonstrate enterprise-level engineering applied to the homelab community. Whether you're monitoring a single media server or managing an MSP's client infrastructure, Parity scales effortlessly while keeping your data secure.

Don't settle for pinch-to-zoom web interfaces. Experience true mobile server management today. Star the repository to support ongoing development, clone the code to start building, and join the community of users who've already transformed their workflows. Your Unraid servers deserve a client as modern as the hardware they run on.

Ready to revolutionize your mobile Unraid experience? Visit the official repository at github.com/shreyaspapi/parity and take the first step toward effortless server management.