Swift Network Reachability: Check macOS Internet Access

Checking for Active Internet Connection in macOS: A Developer’s Guide

In modern macOS applications, maintaining seamless user experiences requires handling internet connectivity gracefully. Whether it’s syncing data, fetching remote content, or enabling cloud features, checking for an active internet connection is essential. However, dealing with network variability on desktop systems—especially with Ethernet, Wi-Fi, and VPNs—introduces complexity.

This guide is tailored for macOS developers who want to reliably detect and monitor internet connectivity using modern Swift techniques and Objective-C alternatives. We’ll explore how to use the Network framework, verify actual internet access, and handle diverse network scenarios with best practices.

Understanding Network Connectivity in macOS

Types of Connections

macOS supports multiple network interfaces, including:

Wi-Fi: Common on laptops and mobile setups.
Ethernet: Preferred for desktops and stable connections.
VPN: Routes traffic through secure tunnels, complicating direct internet checks.

Each type may behave differently in terms of latency, reliability, and accessibility, making robust detection crucial.

Network Reachability vs. Internet Access

Network reachability refers to the ability to connect to a network, but not necessarily the internet. A device could be connected to a local network with no actual internet access. Thus, developers must distinguish between:

Reachable network (e.g., connected to a router).
Internet access (e.g., can fetch a web page or ping an external server).

Using Network Framework for Reachability (macOS 10.14+)

Apple’s Network framework is the modern approach for checking network status in macOS and iOS.

Setting Up NWPathMonitor in Swift

import Network

let monitor = NWPathMonitor()
let queue = DispatchQueue(label: "NetworkMonitor")

monitor.pathUpdateHandler = { path in
    if path.status == .satisfied {
        print("Internet connection is available.")
    } else {
        print("No internet connection.")
    }

    print("Interface Type: \(path.availableInterfaces.map { $0.type })")
}

monitor.start(queue: queue)

Handling NWPath.Status

.satisfied: Network is available.
.unsatisfied: No connection is currently available.
.requiresConnection: Additional action is needed to establish a connection (e.g., VPN login).

Checking Interface Types

if path.usesInterfaceType(.wifi) {
    print("Connected via Wi-Fi")
} else if path.usesInterfaceType(.wiredEthernet) {
    print("Connected via Ethernet")
}

Monitoring Changes

NWPathMonitor continuously watches for changes, making it ideal for long-running apps and background tasks. Always start and stop it appropriately to conserve resources.

Checking for Actual Internet Access

Network reachability isn’t enough. To confirm real connectivity, make a lightweight request to a reliable endpoint.

Swift + URLSession Example

func checkInternetAccess(completion: @escaping (Bool) -> Void) {
    guard let url = URL(string: "https://www.apple.com/library/test/success.html") else {
        completion(false)
        return
    }

    var request = URLRequest(url: url)
    request.timeoutInterval = 5.0

    URLSession.shared.dataTask(with: request) { _, response, error in
        if let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 {
            completion(true)
        } else {
            completion(false)
        }
    }.resume()
}

Best Practices

Use lightweight endpoints (like Apple, Google, or a custom health check server).
Set timeout intervals to avoid long waits on unstable networks.
Avoid overusing checks to reduce server load and battery drain.

Handling Different Network Scenarios

No Internet Connection

Use NWPath.Status.unsatisfied or failed URLSession response to detect and notify users.

Limited or Slow Connections

Monitor request durations and fallback gracefully:

request.timeoutInterval = 3 // Adjust based on app needs

Network Changes

Use NWPathMonitor to listen and react in real-time:

monitor.pathUpdateHandler = { path in
    // Respond to connectivity changes
}

VPN Detection

Detect VPN via interface type:

if path.usesInterfaceType(.other) {
    print("Possibly connected via VPN")
}

For exact VPN detection, consider examining routing tables or using third-party APIs.

User Experience Considerations

Clear Feedback

Provide meaningful messages:

"No internet connection. Please check your network settings."

Avoid vague errors like “Request failed.”

Background Tasks

Handle suspensions and resume network checks appropriately in AppDelegate lifecycle events.

Best Practices for Network Monitoring

Avoid polling: Prefer event-driven monitoring via NWPathMonitor.
Use background-friendly APIs for long-running apps.
Throttle connectivity checks to preserve performance and battery.
Test on various interfaces and with VPNs enabled.

Error Handling and Debugging

Common Errors

NSURLErrorNotConnectedToInternet
NSURLErrorTimedOut
NWPathMonitor never starts (usually due to missing queue).

Debugging Tips

Use Xcode’s Network Debugger (Debug > Network).
Monitor logs in Console.app filtered by your app’s bundle ID.
Use breakpoints inside NWPathMonitor handlers for live observation.

Objective-C Compatibility

For macOS apps using Objective-C or targeting older systems, use the System Configuration framework:

#import <SystemConfiguration/SystemConfiguration.h>

- (BOOL)isConnectedToNetwork {
    SCNetworkReachabilityRef reachability = SCNetworkReachabilityCreateWithName(NULL, "apple.com");
    SCNetworkReachabilityFlags flags;
    BOOL success = SCNetworkReachabilityGetFlags(reachability, &flags);
    CFRelease(reachability);

    return success && (flags & kSCNetworkReachabilityFlagsReachable) &&
           !(flags & kSCNetworkReachabilityFlagsConnectionRequired);
}

Note: This does not confirm internet access—only that a network is reachable.

Conclusion

Checking for an active internet connection in macOS is more than verifying reachability—it’s about confirming true connectivity in real-time. By leveraging the modern Network framework alongside lightweight connectivity tests, you can deliver resilient, user-friendly macOS apps that handle connectivity changes smoothly.

Start implementing NWPathMonitor, use smart URLSession checks, and ensure graceful handling of all network states. For more details, consult the official Apple Network framework documentation and stay updated with best practices.

How to Check Internet Connection in macOS Using Swift