How to Connect to WiFi with Python: Network Automation and Management

Automation of network tasks is becoming standard in modern IT infrastructure, and wireless connection management is no exception. Scenarios requiring switching between access points or monitoring signal quality are often resolved more quickly using scripts than by manually manipulating the operating system interface. Using a programming language Python allows you to create flexible tools for interacting with a Wi-Fi adapter at the system level.

In this article, we'll take a detailed look at how to connect to WiFi via Python, using various approaches: from native operating system libraries to low-level system calls. You'll learn how to manage connection profiles, scan available networks, and analyze signal strength in real time, which is especially relevant for tasks IoT and server administration without a graphical interface.

It's worth noting that implementation methods can vary significantly depending on the platform. If you're working on Windows, you'll have to rely on COM objects or command-line utilities, while in a Linux environment, the COM bundle predominates. wpa_supplicant And nmcliUnderstanding these differences is critical to writing cross-platform code.

Basics of working with wireless interfaces

Before writing code, it's important to understand how the operating system controls the wireless adapter. Python itself doesn't have built-in functions for directly controlling the radio module, so it acts as an intermediary, sending commands to the OS kernel or system services. Interfaces can be in different states: disabled, scanning or connected, and the script must be able to correctly handle transitions between them.

To interact with the network stack, two strategies are most often used: calling external executable files through a module subprocess or using specialized wrapper libraries. The first method is universal, but less elegant and can be slower due to the overhead of process creation. The second method is preferable for long-term projects, as it provides better readability and error handling.

It's important to consider access rights. Network state changes (connecting, disconnecting, deleting profiles) almost always require administrator privileges or root-rights. Running a script without the appropriate rights will result in access errors, even if the code syntax is correct. In Linux, this is resolved via sudo, and in Windows - by running as administrator.

⚠️ Warning: When working with network settings through scripts, you risk losing the connection to the remote server. If you're running code on a remote machine, make sure you have an alternative access channel (e.g., your hosting provider's management console) in case the script blocks the network interface.

Below is a table comparing the main approaches to WiFi management depending on the operating system:

Using the PyWiFi library on Windows

For Windows users, the most convenient solution is the library pywifiIt is a wrapper around the native Windows WLAN API, allowing you to manage connections, scan networks, and work with profiles without having to write cumbersome code. ctypes Or use COM objects directly. Installation is standard via pip: pip install pywifi.

The connection process begins with the creation of an object WiFi and retrieve the first available interface. It's important to understand that a computer may have multiple network adapters, so the script must be able to identify the wireless interface by checking its type. After that, you can initiate a scan for available networks, which will take a few seconds.

The code below demonstrates the basic connection structure. Note the use of classes. Profile to describe network parameters such as SSID (network name) and security key. If the network is open, the key field can be left blank, but for WPA2-protected networks, you must enter the correct password.

import pywifi
from pywifi import const

def connect_to_wifi(ssid, password):
wifi = pywifi.PyWiFi()
iface = wifi.interfaces()[0]

iface.disconnect()
profile = pywifi.Profile()
profile.ssid = ssid
profile.auth = const.AUTH_ALG_OPEN
profile.akm.append(const.AKM_TYPE_WPA2PSK)
profile.cipher = const.CIPHER_TYPE_CCMP
profile.key = password

iface.remove_all_network_profiles()
tmp_profile = iface.add_network_profile(profile)
iface.connect(tmp_profile)
return iface.status() == const.IFACE_CONNECTED

When working with pywifi It's worth remembering that the library may not work correctly with some drivers or in virtual machines. There are also limitations on the network scanning frequency: excessively frequent requests may be ignored by the adapter driver to avoid overloading.

Encoding issues in Windows

Older versions of Windows (7, 8) and some locales may experience encoding issues when transmitting SSIDs containing Cyrillic characters. The solution is to use raw strings or explicitly encode the strings in UTF-8 before passing them to the API.

Managing WiFi in Linux with wpa_supplicant

In the Linux world, the approach to network management is more unified, but requires an understanding of how the daemon works. wpa_supplicantThis is a background process responsible for establishing connections and controlling the wireless interface. Python scripts in this environment often act as a client, sending commands to the daemon via a control socket or D-Bus.

The most reliable, though not the easiest, way is direct interaction with wpa_cliThis tool allows you to send text commands to the daemon. The script must be able to generate the correct command sequences: first, disconnect from the current network, then add a new configuration, select it, and initiate a connection. Errors at any stage will cause the interface to freeze.

An alternative is to use NetworkManager via its D-Bus interface or utility nmcliThis is the preferred method for desktop distributions (Ubuntu, Fedora), as it integrates with system settings and does not interfere with the graphical interface. However, on servers where NetworkManager may not be available, knowledge wpa_supplicant remains a mandatory skill.

⚠️ Attention: Configuration files wpa_supplicant (/etc/wpa_supplicant/wpa_supplicant.conf) store passwords in cleartext or hashed format. Don't allow these files to leak, as this compromises your network security. Use access rights. chmod 600 for protection.

Let's look at an example of use nmcli via Python, which is a more modern approach for systemd-based distributions:

import subprocess

def connect_linux_nmcli(ssid, password):
try:
# Connecting to the network
subprocess.run([
"nmcli", "device", "wifi", "connect", ssid, "password", password
], check=True, capture_output=True)
return True
except subprocess.CalledProcessError as e:
print(f"Connection error: {e.stderr.decode()}")
return False

Usage subprocess.run with parameter check=True Ensures that the script will stop and report an error if the command fails. This is an important part of exception handling, preventing further script steps from executing in the event of a failure.

Analysis of available networks and signal strength

One of the most common tasks is not just connecting, but choosing the best available network. This requires the ability to scan the surrounding area and analyze the parameters of the access points found. The key metric here is RSSI (Received Signal Strength Indicator), which shows the signal level in dBm.

RSSI values ​​typically range from -30 dBm (excellent signal) to -90 dBm (barely noticeable signal). When writing a network selection algorithm, it's logical to filter out networks with signal strengths below a certain threshold, such as -75 dBm, as connections to these networks will be unstable. Channel load is also important to consider, although obtaining this information through standard Python APIs is more difficult.

Here's how you can filter networks by signal strength using pywifi in Windows:

def get_strongest_network(min_signal=-80):
wifi = pywifi.PyWiFi()
iface = wifi.interfaces()[0]
iface.scan()
# A short delay to complete the scan
import time
time.sleep(2)
networks = iface.scan_results()

best_net = None
max_signal = -100

for net in networks:
if net.signal > max_signal and net.signal > min_signal:
max_signal = net.signal
best_net = net

return best_net

When scanning networks in Linux using iwlist or nmcli You will receive a list in text or JSON format, which needs to be parsed. Regular expressions (re module) will be indispensable here for extracting numerical values ​​of a signal from the string output of utilities.

Error handling and password security

Network connections are full of unpredictability: a driver might hang, an access point might not respond, and a password might be incorrect. Robust code must anticipate all these scenarios. Using blocks try-except Required, especially when calling external processes or accessing system APIs.

Particular attention should be paid to password storage. Hard-coding passwords in the script's source code is a bad practice. Instead, use environment variables, configuration files with restricted access rights, or specialized keyring. On Linux, you can use dbus and the system password storage, in Windows - Credential Manager.

Logging is another critical aspect. All connection attempts, successful and unsuccessful, should be recorded in a log file. This will help diagnose problems, especially if the script is running in the background. However, when logging the process, never write passwords in plain text, even if there is an error.

⚠️ Attention: WiFi control interfaces (especially wpa_cli (and sockets) can be vulnerable to local attacks if access rights are not configured. Ensure that management sockets are accessible only to the root user or a group with minimal privileges.

Below is an example of how to securely obtain a password from environment variables:

import os

def get_wifi_credentials(ssid_name):
# Form a variable name, for example WIFI_HOME_PASSWORD
env_var = f"WIFI_{ssid_name.upper().replace(' ', '_')}_PASSWORD"
password = os.getenv(env_var)

if not password:
raise ValueError(f"Password for network {ssid_name} not found in environment variables")
return password

FAQ: Frequently Asked Questions

Is it possible to connect to a hidden network (Hidden SSID) using Python?

Yes, it is possible. In the connection profile (for example, in pywifi or configurations wpa_supplicant) you must explicitly specify the SSID and set the hidden network flag. However, hidden networks do not respond to broadcast requests, so scanning may not reveal them, and you need to know the exact network name in advance.

Why doesn't the script detect the WiFi adapter in the virtual machine?

Virtual machines (VirtualBox, VMware) typically emulate a wired network adapter. For the script to work with real WiFi, you need to pass a physical USB WiFi adapter through to the virtual machine (USB Passthrough), as emulating a wireless interface with airspace scanning capabilities is difficult using standard tools.

How to speed up the process of reconnecting between networks?

The main delay occurs during scanning. If you know the MAC address (BSSID) of the access point, you can try connecting directly to it, bypassing the full channel scan. Disabling background services that could hijack control of the adapter while the script is running also helps.

Does this code work on Raspberry Pi?

Yes, the Raspberry Pi runs Linux, so approaches with wpa_supplicant, nmcli or subprocess They work there natively. Library pywifi can also be installed, but native Linux tools often work more stably on ARM architecture.

Can Python be used to brute force WiFi attacks?

Technically, Python allows you to create packages and interact with the adapter at a low level (using libraries like Scapy), which theoretically allows for penetration testing. However, using such scripts on other people's networks is illegal. This article only covers legitimate administration and connection to known networks.