How to create a simple socket server and client in Python

How to Create a Simple Socket Server and Client in Python

/ Python Tutorials / By

Introduction

Socket programming in Python allows two or more computers or applications to communicate with each other over a network. In this tutorial, you will learn how to create a simple socket server and client in Python using the built-in socket module.

The project demonstrates a basic client-server communication system. The server listens for incoming connections, while the client connects to the server and sends a message. The server receives the message and can send a response back to the client.

This is a useful beginner-level Python project for students learning network programming, TCP/IP communication, client-server architecture, and Python socket programming.

You can also explore our Python Projects for more practical Python applications.

What Is Socket Programming?

A socket is an endpoint that allows applications to communicate over a network.

In a typical client-server architecture:

Client → Connection Request → Server

After the connection is established:

Client ↔ Server

The client can send data to the server, and the server can process the data and return a response.

Python provides the built-in socket module, so you don’t need to install an additional package for this basic project.

What Is a Socket Server?

A socket server is a program that waits for incoming client connections.

The basic server workflow is:

  1. Create a socket.
  2. Bind the socket to an IP address and port.
  3. Listen for connections.
  4. Accept a client connection.
  5. Receive data.
  6. Process the request.
  7. Send a response.
  8. Close the connection.

What Is a Socket Client?

A socket client is a program that connects to a server.

The basic client workflow is:

  1. Create a socket.
  2. Connect to the server.
  3. Send data.
  4. Receive the server response.
  5. Close the connection.

Client-Server Communication Using Python

The complete communication process looks like this:

Python Client

↓

Connect to Server

↓

Python Socket Server

↓

Receive Message

↓

Process Message

↓

Send Response

↓

Python Client Receives Response

Technologies Used

TechnologyPurpose
PythonProgramming language
SocketNetwork communication
TCPReliable communication protocol
VS Code / PyCharmCode editor
Command Prompt / TerminalRunning the programs

Python’s built-in socket library is sufficient for this basic project.

How to Create a Simple Socket Server in Python

Create a file named:

server.py

Add the following code:

import socketHOST = "127.0.0.1"PORT = 12345server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)server_socket.bind((HOST, PORT))server_socket.listen(1)print("Server is listening...")connection, address = server_socket.accept()print("Connected by:", address)data = connection.recv(1024).decode()print("Client:", data)response = "Hello from Python Server!"connection.send(response.encode())connection.close()server_socket.close()

Understanding the Server Code

Import the socket module

import socket

The socket module provides the functions required for network communication.

Define the host and port

HOST = "127.0.0.1"PORT = 12345

127.0.0.1 represents the local computer.

The port number identifies the communication endpoint used by the application.

Create the socket

server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

Here:

  • AF_INET specifies IPv4.
  • SOCK_STREAM creates a TCP socket.

Bind the socket

server_socket.bind((HOST, PORT))

The server associates the socket with the selected IP address and port.

Listen for clients

server_socket.listen(1)

The server starts listening for incoming connection requests.

Accept a connection

connection, address = server_socket.accept()

The program waits until a client connects.

Receive data

data = connection.recv(1024).decode()

The server receives up to 1024 bytes and converts the received bytes into a string.

Send a response

connection.send(response.encode())

The response is converted into bytes before being transmitted through the socket.

How to Create a Simple Socket Client in Python

Now create another file:

client.py

Add:

import socketHOST = "127.0.0.1"PORT = 12345client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)client_socket.connect((HOST, PORT))message = "Hello from Python Client!"client_socket.send(message.encode())response = client_socket.recv(1024).decode()print("Server:", response)client_socket.close()

Understanding the Client Code

The client creates a TCP socket using:

socket.socket(socket.AF_INET, socket.SOCK_STREAM)

It then connects to the server:

client_socket.connect((HOST, PORT))

The client sends a message:

client_socket.send(message.encode())

Finally, it receives the server response:

response = client_socket.recv(1024).decode()

How to Run the Python Socket Project

Save both files in the same folder:

socket-project/
│
├── server.py
└── client.py

Step 1: Open the terminal

Navigate to the project directory.

Step 2: Start the server

Run:

python server.py

You should see:

Server is listening...

The server is now waiting for a client.

Step 3: Open another terminal

Run:

python client.py

The client connects to the server and sends:

Hello from Python Client!

The server can respond with:

Hello from Python Server!

Expected Output

Server

Server is listening...
Connected by: ('127.0.0.1', 50000)
Client: Hello from Python Client!

Client

Server: Hello from Python Server!

The exact temporary client port displayed by your operating system may be different.

How the Project Works

The complete process is:

        CLIENT
           |
           | Connect
           ↓
      TCP SOCKET
           |
           ↓
        SERVER
           |
           | Receive Message
           ↓
       Process Data
           |
           | Send Response
           ↓
        CLIENT

This demonstrates basic TCP client-server communication using Python.

TCP vs UDP Socket Programming

Python sockets can be used with different transport protocols.

TCP

TCP provides reliable, connection-oriented communication.

It is suitable when:

  • Data delivery is important
  • Messages should arrive in order
  • A connection between client and server is required

The example in this tutorial uses TCP:

socket.SOCK_STREAM

UDP

UDP is connectionless and generally has lower communication overhead.

A UDP socket can be created using:

socket.SOCK_DGRAM

UDP can be useful for applications where speed and low overhead are more important than guaranteed delivery.

Software Requirements

You need:

  • Python 3.x
  • VS Code, PyCharm, or another Python editor
  • Windows, Linux, or macOS
  • Command Prompt or Terminal

No external Python package is required for this basic socket project.

Hardware Requirements

Basic hardware is sufficient:

  • Dual-core processor or better
  • 4 GB RAM or more
  • A few MB of free storage
  • Network connection if testing between different computers

For localhost testing, an internet connection is not required.

Testing the Socket Server on Two Computers

The example above uses:

127.0.0.1

This means the server and client are running on the same computer.

To test communication between two computers on the same local network, the server can listen on an appropriate network interface and the client can connect using the server computer’s local IP address.

For example, the client may use:

HOST = "192.168.1.10"

where the address is the server computer’s actual local-network IP.

Only connect to computers and networks you own or have permission to access.

Common Socket Programming Errors

Connection Refused

You may see:

ConnectionRefusedError

Possible causes include:

  • Server isn’t running.
  • Incorrect IP address.
  • Incorrect port.
  • Firewall blocking the connection.

Start the server before running the client.

Address Already in Use

You may encounter:

OSError: [Errno 98] Address already in use

or a similar Windows error.

This can happen when another process is already using the selected port.

Try another unused port, such as:

PORT = 12346

Make sure the client and server use the same port.

Client Cannot Connect

Check:

  • Server IP address
  • Port number
  • Firewall configuration
  • Whether the server is running
  • Whether both computers are connected to the same network when testing locally

Key Features of This Project

The simple Python socket project demonstrates:

  • TCP communication
  • Client-server architecture
  • Socket creation
  • IP address and port configuration
  • Sending data
  • Receiving data
  • Encoding and decoding messages
  • Connection management
  • Basic network programming

Applications of Socket Programming

Socket programming is used as a foundation for many network applications, including:

  • Chat applications
  • File transfer systems
  • Multiplayer games
  • Network monitoring tools
  • Client-server applications
  • Real-time communication systems
  • Remote service applications
  • IoT communication systems

More advanced applications require authentication, encryption, input validation, error handling, and other security controls.

Advantages

The main advantages of Python socket programming include:

  • Easy to learn
  • Built into Python
  • Useful for understanding networking
  • Supports TCP and UDP
  • Suitable for client-server applications
  • Good for educational projects
  • Can be extended into real-time applications

Limitations

This basic implementation has several limitations:

  • No authentication
  • No encryption
  • Basic error handling
  • Handles only a simple communication flow
  • Not designed for production deployment
  • Limited scalability
  • No persistent data storage

For production applications, additional security and reliability mechanisms are required.

Future Scope

This simple project can be expanded into a more advanced application.

1. Multi-Client Server

Use threads or asynchronous programming to handle multiple clients.

2. Chat Application

Allow multiple clients to exchange messages through the server.

3. File Transfer

Add functionality for transferring files between authorized clients and servers.

4. Authentication

Add user authentication before allowing clients to access services.

5. Encryption

Use appropriate secure communication mechanisms for sensitive data.

6. Graphical User Interface

Create a GUI using Tkinter or another Python framework.

7. Web-Based Interface

Combine the networking concepts with a web application or API architecture.

Frequently Asked Questions

What is socket programming in Python?

Socket programming is a method of enabling applications to communicate with each other over a network using sockets.

How do I create a socket server in Python?

Import Python’s socket module, create a socket, bind it to an address and port, listen for connections, accept a client, and exchange data.

How do I create a socket client in Python?

Create a socket and use the connect() method to connect to the server. The client can then send and receive data.

Which protocol is used in this Python socket project?

This tutorial uses TCP, implemented using:

socket.SOCK_STREAM

Do I need to install a Python socket library?

No. The socket module is included with the Python standard library.

Can I run the client and server on the same computer?

Yes. Using 127.0.0.1, you can run both programs on the same computer for testing.

Can I run the server and client on different computers?

Yes. They can communicate over a network when the server is configured appropriately and the client can reach the server’s IP address and port.

Conclusion

How to Create a Simple Socket Server and Client in Python is a useful beginner project for understanding network communication and client-server architecture. Using Python’s built-in socket module, you can create a TCP server that listens for connections and a client that connects to the server and exchanges messages.

This project provides a practical introduction to Python socket programming, TCP communication, IP addresses, ports, data transmission, and client-server architecture. It can also serve as a foundation for more advanced projects such as chat applications, file-transfer systems, and real-time network applications.

    Our Blogs
    Our Blogs