Building NETRadar - My First Real Network Scanner in Python

Radosław — Sun, 12 Apr 2026 15:28:06 +0000

Building NetRadar – My First Real Network Scanner in Python

Instead of doing another tutorial project, I decided to build something that actually works in a real environment.

That’s how NetRadar came to life — a simple CLI tool for scanning local networks and detecting open ports.

💡 Why I built it

I didn’t want to just follow guides anymore.
I wanted to understand how networking actually works — not just in theory, but in practice.

So the idea was simple:

Scan a local network → find active devices → check which ports are open.

At first, it sounded straightforward.
In reality, it turned into a much more interesting challenge.

🔧 What NetRadar does

NetRadar is a CLI-based tool that allows you to:

discover active hosts in a local network
scan TCP ports (quick / deep modes)
detect open ports using sockets
map ports to known services (HTTP, SSH, RDP, etc.)
validate user input (IP ranges, modes, etc.)
export results to a structured JSON file
display clean, readable output in the terminal

🖥️ Example output

======= RESULTS =======

Host: 192.168.0.1
  80 (HTTP)
  443 (HTTPS)

Host: 192.168.0.5
  No open ports

======= SUMMARY =======
Active hosts: 2
Open ports found: 2

📁 JSON output

One of the things I focused on was making the output usable, not just visible.

{
  "scan_info": {
    "base": "192.168.0.",
    "range": "192.168.0.1-192.168.0.10",
    "mode": "quick",
    "timestamp": "2026-04-12 20:15:33"
  },
  "results": [
    {
      "ip": "192.168.0.1",
      "open_ports": [
        { "port": 80, "service": "HTTP" }
      ]
    }
  ]
}

⚙️ How it works (simplified)

1. Host discovery

I used subprocess to ping IP addresses:

ping -n 1 192.168.0.x

If the response is successful → the host is active.

2. Port scanning

This was the most interesting part.

I used Python sockets:

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.settimeout(0.5)
result = sock.connect_ex((host_ip, port))

If result == 0, the port is open.

3. Data structure

Instead of just printing results, I stored everything in dictionaries:

{
  "ip": "192.168.0.1",
  "active": True,
  "open_ports": [
    {"port": 80, "service": "HTTP"}
  ]
}

This made it easy to:

print results
export to JSON
extend the project later

🧠 What I learned

This project taught me a lot more than I expected:

how socket connections actually work
how to design clean and usable data structures
how to handle user input properly
how to turn logic into a real CLI tool
how small UX details (like output formatting) matter

The biggest difference compared to tutorials was this:

I had to solve real problems on my own.

🚀 Challenges

Some things were harder than I thought:

handling invalid user input
structuring the data cleanly
making the output readable
debugging network behavior

At one point, nothing worked and I had no idea why —
but fixing those issues was the most valuable part.

🔥 What’s next (NetRadar V2)

I’m already working on improvements:

multi-threading (faster scanning)
better performance
more advanced features
possibly a simple GUI

🧭 Final thoughts

This is not a huge project, but it’s the first one that actually feels like a real tool, not just an exercise.

And that changed the way I approach learning.

Instead of just consuming content, I’m trying to build things that:

solve real problems
can be improved over time
actually work outside of tutorials

If you have any feedback or ideas — I’d love to hear them 👇

DEVLOG #1 HOST DISCOVERY

Radosław — Thu, 02 Apr 2026 14:42:04 +0000

Worked a bit more on my network audit tool today.

Added host discovery – scanning an IP range and checking which hosts are active using ping.
Also changed how I store the data, so each host is now an object instead of just an IP. Makes it easier to build on later.

Small step, but it finally starts to feel like an actual tool.

Next step: port scanning.

Starting my devlog

Radosław — Tue, 31 Mar 2026 13:42:57 +0000

I decided to start sharing what I’m building instead of just keeping everything to myself.

I’m an IT student and I’ve been learning Python, networking and a bit of web development. So far I’ve done a few small projects, but now I want to take things more seriously and actually document the process.

Right now I’m starting a bigger project — a CLI network audit tool. The idea is to scan a local network, check active hosts and basic ports, and turn that into a readable report.

Nothing crazy yet, but definitely a step up from what I’ve done before.

I’ll be posting updates as I build it — what works, what doesn’t, and what I learn along the way.

If you’re also learning or working on similar stuff, feel free to connect or share your thoughts.

Let’s see where this goes.

GitHub: https://github.com/radoslaw-dev
Portfolio: https://radoslaw-dev.github.io
LinkedIn: https://www.linkedin.com/in/rados%C5%82aw-cis-60b03339b/

DEV Community: Radosław