Introduction

Finding a machine’s “local IP address” sounds simple, but the phrase can mean different things. Sometimes you want the loopback address, sometimes the address used to reach the local network, and sometimes every address bound to the host.

Know Which Address You Actually Need

On a modern machine, several addresses may exist at the same time:

• '127.0.0.1 for loopback'
• one or more IPv4 addresses on Wi-Fi or Ethernet
• possibly IPv6 addresses
• virtual adapter addresses created by VPNs, containers, or hypervisors

That is why there is no single perfect one-line answer. The right method depends on what you want to do next.

Method 1: The Practical Outbound Address Trick

If your goal is “which local IP would this machine use to talk to the network,” the most reliable stdlib-only technique is to open a UDP socket and inspect the chosen local endpoint.

1import socket
2
3
4def get_outbound_ip() -> str:
5    with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as sock:
6        sock.connect(("8.8.8.8", 80))
7        return sock.getsockname()[0]
8
9
10print(get_outbound_ip())

This does not send useful application data to the remote host. The connect call is used so the operating system selects the appropriate local interface and source address.

For many server and tooling tasks, this is the most useful answer because it tells you the address other machines on the same route are likely to see.

Method 2: Hostname Resolution

You will also see examples like this:

1import socket
2
3hostname = socket.gethostname()
4ip = socket.gethostbyname(hostname)
5print(hostname, ip)

This can work, but it is less dependable. On some systems it returns 127.0.0.1, on others it returns a usable LAN address, and on some machines it depends on local DNS or hosts-file configuration.

Use it only if you understand how the target machines resolve their own hostnames.

Method 3: Enumerate All Candidate Addresses

If you want a broader picture, ask the system for all addresses associated with the host.

1import socket
2
3
4def all_ipv4_addresses() -> list[str]:
5    hostname = socket.gethostname()
6    infos = socket.getaddrinfo(hostname, None, family=socket.AF_INET, type=socket.SOCK_STREAM)
7    addresses = sorted({info[4][0] for info in infos})
8    return addresses
9
10
11print(all_ipv4_addresses())

This is useful when a machine has several active adapters. The downside is the same as hostname-based resolution in general: the result depends on how the operating system and local name resolution are configured.

Working with IPv6

If your environment uses IPv6, do not assume IPv4-only logic is enough. You can adapt the same enumeration technique to request AF_INET6 addresses.

1import socket
2
3
4def all_ipv6_addresses() -> list[str]:
5    hostname = socket.gethostname()
6    infos = socket.getaddrinfo(hostname, None, family=socket.AF_INET6, type=socket.SOCK_STREAM)
7    addresses = sorted({info[4][0] for info in infos})
8    return addresses
9
10
11print(all_ipv6_addresses())

Whether those addresses are useful depends on your network, scope identifiers, and whether the service you are building listens on IPv6 at all.

Choosing the Best Method

Use the UDP socket method when you need the address used for outbound network traffic.

Use hostname resolution when you specifically care about how the machine’s hostname resolves in that environment.

Use getaddrinfo when you need a list of candidate addresses rather than one answer.

In real-world tools, it is common to expose a command-line option or configuration setting so the operator can choose the address explicitly. Automatic detection is helpful, but network setups are messy enough that manual override is often the most robust design.

Common Pitfalls

Assuming socket.gethostbyname(socket.gethostname()) always gives the LAN address is the classic mistake. On many systems it resolves to loopback.

Hard-coding a single interpretation of “local IP” is another problem. Decide whether you want loopback, outbound, or all interface addresses.

Ignoring IPv6 can also produce surprising bugs on networks where IPv6 is preferred or required.

Finally, remember that VPN software and container runtimes can change which address is considered local or outbound. If the result looks strange, inspect the machine’s active interfaces before blaming Python.

Summary

• “local IP address” can mean different things depending on context
• the UDP socket technique is the most practical stdlib-only way to find the outbound IPv4 address
• hostname resolution is simple but less reliable across machines
• 'socket.getaddrinfo is useful when you need multiple candidate addresses'
• network configuration, VPNs, and IPv6 all affect what the correct answer should be