NWPathMonitor: what it is, network monitoring and working in iOS

What is NWPathMonitor?

NWPathMonitor is a class from the Network framework introduced by Apple in iOS 12 and macOS 10.14 Mojave. It provides a modern API for tracking changes in the device’s network path — the combination of network interfaces through which the application’s traffic passes.

Before iOS 12, the Reachability library built on the C-based SystemConfiguration framework was used for network monitoring. NWPathMonitor is a native Swift alternative with a richer API, support for modern connection types (VPN, multipath, LTE, 5G) and built-in GCD integration.

The key difference between NWPathMonitor and Reachability — the NWPath object provides not just a binary “available/unavailable” status, but a complete picture of the path: used interfaces, their priority, costs, roaming status, and proxy and VPN capabilities. The developer gets comprehensive information for making decisions about network requests.

History of the Network framework

The Network framework emerged as a modern replacement for low-level C APIs — CFStream and BSD Sockets. It provides a unified interface for network communication across all Apple platforms, including watchOS and tvOS. NWPathMonitor is part of this framework alongside NWConnection, NWListener and NWBrowser.

The Network framework is written in Swift and uses GCD for asynchronous processing. This means that NWPathMonitor callbacks execute on the specified dispatch queue, integrating with the application’s existing multithreading architecture without manual thread management.

How to Use NWPathMonitor in an Application

Using NWPathMonitor starts with creating a class instance and configuring the pathUpdateHandler callback. Then the start method is called with a dispatch queue where the closure will execute. Monitoring is stopped by the cancel method, which also releases resources.

import Network

class NetworkMonitor {
    private let monitor = NWPathMonitor()
    private let queue = DispatchQueue("monitor")

    func startMonitoring() {
        monitor.pathUpdateHandler = { path in
            if path.status == .satisfied {
                print("Network available")
            } else {
                print("Network unavailable")
            }
        }
        monitor.start(on: queue)
    }

    func stopMonitoring() {
        monitor.cancel()
    }
}

Working with Interface Type

NWPathMonitor can be configured to monitor only a specific interface type. Use the initializer NWPathMonitor(requiredInterfaceType:) with the NWInterface.InterfaceType parameter — .wifi, .cellular, .wiredEthernet or .loopback. If no type is specified, monitoring covers all interfaces.

Practical example: a streaming application can monitor only Wi-Fi and warn the user about switching to cellular data. Checking isConstrained and isExpensive in NWPath allows determining whether the current connection is metered or speed-limited.

Monitoring Lifecycle

Monitoring should start at application launch or when entering the foreground, and stop when entering the background. It is recommended to create one NWPathMonitor instance for the entire application (singleton) and use it from different modules through a protocol or service layer.

NWPath Properties and Capabilities

NWPath is an object passed to the pathUpdateHandler that describes the current state of the network path. It contains five key properties covering most network monitoring scenarios. NWPath.Status — an enumeration with three states: satisfied (available), unsatisfied (unavailable), and requiresConnection (needs connection).

Checking Costs and Restrictions

The isExpensive property is a critical flag for applications working with large amounts of data. If isExpensive = true, the application should reduce streaming quality, postpone update downloads, or warn the user. isConstrained indicates that Low Data Mode is enabled.

To check internet availability (not just network), use the usesInterfaceType method. If the device is connected to Wi-Fi without internet — NWPath may show satisfied, but actual access is absent. In such cases, additional validation via NWConnection is required.

NWPathMonitor Implementation Examples

Let’s look at an advanced NWPathMonitor implementation with cost handling, interface types, and ViewModel notification through a publisher. The example uses the Combine framework for reactive UI updates when the network state changes.

import Network
import Combine

final class NetworkManager: ObservableObject {
    static let shared = NetworkManager()
    @Published private(set) var isConnected = true
    @Published private(set) var isExpensive = false

    private let monitor = NWPathMonitor()
    private let queue = DispatchQueue("NetworkMonitor")

    private init() {
        monitor.pathUpdateHandler = { [weak self] path in
            DispatchQueue.main.async {
                self?.isConnected = path.status == .satisfied
                self?.isExpensive = path.isExpensive
            }
        }
        monitor.start(on: queue)
    }

    func checkInterface() -> NWInterface.InterfaceType {
        let path = monitor.currentPath
        if path.usesInterfaceType(.wifi) { return .wifi }
        if path.usesInterfaceType(.cellular) { return .cellular }
        return .other
    }
}

Handling Network Loss with Deferred Action

When a connection is lost, you may need not only to notify the UI but also to perform deferred actions — for example, save a draft request for later sending. Implement a queue of deferred requests that accumulates operations during unsatisfied status and sends them when satisfied is restored.

The ReachabilityManager with a delegate pattern is ideal for this task: NWPathMonitor notifies the manager, the manager updates the queue and UI. When the status changes to satisfied, the queue automatically flushes, and the UI receives a connection restoration indication.

NWPathMonitor vs Reachability

Before NWPathMonitor, the standard solution for network monitoring in iOS was Apple’s Reachability library (example from documentation), built on SystemConfiguration. The main differences: Reachability works through SCNetworkReachability in C, does not support modern network types, and only provides a binary availability response.

NWPathMonitor addresses these limitations: it is written in Swift, supports VPN, multipath, 5G and LTE, provides detailed information about each interface, and works asynchronously through GCD. Reachability is still used in projects with minimum iOS 11 and below support.

When to Use Reachability

If your application supports iOS 11 and below, Reachability remains the only option. For iOS 12+ projects, it is recommended to use NWPathMonitor directly — it integrates better with modern Swift code, Combine, and SwiftUI.

Migration from Reachability to NWPathMonitor is straightforward: simply replace SCNetworkReachability calls with NWPathMonitor, preserving the same handling logic. An abstraction layer (NetworkMonitorProtocol) will allow switching between implementations without changing the application’s business logic.