Architecture and Hardware

What are the 7 network protocols and examples?

The seven network protocols most often listed (IP, TCP, UDP, HTTP, DNS, DHCP and FTP), what each does, how they map to OSI layers and how IoT devices use them.

On this page
  1. The short answer
  2. Why “seven”? Protocols vs the 7 OSI layers
  3. The seven protocols explained
  4. Other protocols you’ll hear about
  5. One example protocol per OSI layer
  6. TCP vs UDP at a glance
  7. How they work together: a sensor sending data to the cloud
  8. Network protocols on embedded and IoT devices
  9. Network protocols vs on-board protocols

The short answer

There’s no official list of “the 7 network protocols”, but the seven most often cited are:

  1. IP (Internet Protocol): addresses and routes packets between networks. Example: every device on the internet has an IP address such as 192.168.1.20.
  2. TCP (Transmission Control Protocol): reliable, ordered delivery of data. Example: loading a web page or downloading a firmware file.
  3. UDP (User Datagram Protocol): fast, connectionless delivery with no delivery guarantee. Example: DNS lookups, voice calls, video streaming.
  4. HTTP/HTTPS (Hypertext Transfer Protocol): requests and responses for web content and APIs. Example: a browser fetching a page, or a device posting data to a REST API.
  5. DNS (Domain Name System): turns names into IP addresses. Example: resolving “example.com” to its server’s address.
  6. DHCP (Dynamic Host Configuration Protocol): automatically gives a device an IP address and network settings. Example: your phone getting an address when it joins Wi-Fi.
  7. FTP (File Transfer Protocol): transfers files between a client and a server. Example: uploading files to a web server, though more secure alternatives such as SFTP are now preferred.

Some lists swap FTP for SMTP (sending email), SSH (secure remote login) or TLS (encryption). All of them belong to the TCP/IP family of protocols that runs the internet.

Why “seven”? Protocols vs the 7 OSI layers

The number seven probably comes from the OSI model, which divides networking into seven layers. The model and the protocol list are different things: the OSI model is a way of organizing networking functions, while protocols are the actual rules that devices follow. Each protocol works at one layer (or spans a couple), and many protocols can exist at the same layer.

The internet itself is built on the simpler TCP/IP model, which is usually described as four layers: link, internet, transport and application. The OSI layers are still widely used as shorthand, which is why people say things like “a layer 3 switch” or “a layer 7 load balancer”.

The seven protocols explained

IP

IP gives every device a logical address and moves packets from source to destination, hopping across routers between networks. It is “best effort”: it doesn’t promise that packets arrive, or arrive in order. IPv4 uses 32-bit addresses (e.g. 192.168.1.20). IPv6 uses 128-bit addresses (e.g. 2001:db8::1) and was created largely because IPv4 addresses ran short.

TCP

TCP sits on top of IP and turns its unreliable packet delivery into a reliable byte stream. It sets up a connection with a three-way handshake (SYN, SYN-ACK, ACK), numbers the data, acknowledges what arrives, retransmits what’s lost and controls the sending rate. Web traffic (HTTP/1.1 and HTTP/2), email, SSH and MQTT all normally run over TCP.

UDP

UDP also sits on top of IP but skips connections, acknowledgements and retransmission. Each message (datagram) is sent once. That keeps the overhead low and avoids delays from retransmissions, which suits DNS queries, real-time voice and video, games and many lightweight IoT protocols. If an application needs reliability over UDP, it has to add it itself.

HTTP and HTTPS

HTTP is the request/response protocol of the web: a client sends a request such as GET /status and the server returns a response with a status code (200 OK, 404 Not Found) and content. HTTPS is HTTP carried over TLS encryption. HTTP traditionally uses port 80 and HTTPS port 443. HTTP is also widely used for device APIs: an embedded device might POST a JSON reading to a server, or host a small configuration page itself.

DNS

DNS is the internet’s naming system. A device asks a DNS resolver for the address behind a name and caches the answer for a set time. Queries usually go over UDP port 53, with TCP used in some cases. Without DNS, devices would need hard-coded IP addresses, which break whenever a server moves.

DHCP

When a device joins a network, DHCP lets it ask for an IP address, subnet mask, default gateway and DNS server instead of being configured by hand. A DHCP server, often built into the home router, leases an address for a period of time. DHCP runs over UDP (ports 67 and 68).

FTP

FTP is one of the oldest internet protocols. It moves files using separate control and data connections, conventionally on ports 21 and 20. Plain FTP sends credentials and data unencrypted, so SFTP (file transfer over SSH) or FTPS (FTP over TLS) are preferred today, and many uses have moved to HTTPS.

Other protocols you’ll hear about

  • SMTP: sends email between mail servers and from clients to servers. IMAP and POP3 retrieve it.
  • SSH: encrypted remote login and command execution, standard for managing Linux devices and servers (port 22).
  • TLS: encrypts and authenticates connections. It secures HTTPS, MQTT over TLS and much more. It’s usually described as sitting between the transport and application layers, and sources differ on which OSI layer to assign it to.
  • ICMP: error and diagnostic messages. The ping command uses it.
  • ARP: finds the hardware (MAC) address that belongs to an IPv4 address on a local network.
  • NTP / SNTP: time synchronization, important for devices that timestamp data or validate TLS certificates.
  • MQTT: a lightweight publish/subscribe messaging protocol widely used in IoT, normally over TCP (port 1883, or 8883 with TLS).

One example protocol per OSI layer

OSI layer Name What it does Example protocols and standards
7 Application Services used by applications HTTP, DNS, DHCP, FTP, SMTP, MQTT
6 Presentation Data formats, encoding, encryption TLS (commonly placed here or at layer 5), data encodings such as JSON
5 Session Managing sessions between applications Mostly handled inside TCP, TLS and applications in practice
4 Transport End-to-end delivery, ports, reliability TCP, UDP
3 Network Logical addressing and routing IP (IPv4, IPv6), ICMP
2 Data link Delivery on one local link, MAC addresses Ethernet, Wi-Fi (IEEE 802.11) framing, ARP (often placed here)
1 Physical Signals on wire, fibre or radio Ethernet physical layers, Wi-Fi radio, RS-485

Real protocols don’t always fit neatly into one OSI layer. Treat the table as a guide rather than a strict rule.

TCP vs UDP at a glance

TCP UDP
Connection Connection set up with a handshake Connectionless
Delivery Reliable, ordered, retransmits lost data Best effort, no ordering or retransmission
Overhead Higher (headers, acknowledgements, state) Lower
Typical uses Web, email, SSH, MQTT, file transfer DNS, streaming, voice, games, CoAP
On small devices Needs more RAM for buffers and connection state Lighter, which suits constrained devices

How they work together: a sensor sending data to the cloud

Imagine a Wi-Fi temperature sensor powering up and sending a reading:

  1. It joins the Wi-Fi network (data link and physical layers).
  2. DHCP gives it an IP address, gateway and DNS server.
  3. SNTP may set its clock so it can timestamp readings and check certificates.
  4. DNS resolves the cloud broker’s hostname to an IP address.
  5. TCP opens a connection to that address. IP carries every packet across the network.
  6. TLS encrypts the connection and verifies the server’s certificate.
  7. MQTT (or HTTPS) publishes the reading, for example to a topic like home/livingroom/temperature.

Each protocol solves one problem and relies on the ones below it.

Network protocols on embedded and IoT devices

Larger embedded systems running Linux get a full network stack from the operating system. Microcontrollers usually rely on a compact TCP/IP stack such as lwIP (common on ESP32 and many vendor SDKs) or the stacks built into RTOSes like Zephyr. Some Wi-Fi and cellular modules run the network stack themselves, and the microcontroller controls them over UART or SPI.

Constraints shape which protocols get used:

  • RAM: TCP connections and especially TLS need buffer memory that a small microcontroller may barely have.
  • Power: battery devices favour short exchanges and protocols with little chatter, such as MQTT or CoAP, a compact UDP-based protocol designed for constrained devices.
  • Security: TLS with proper certificate checking is the norm for anything that talks to the internet. That means managing certificates and keeping the device’s clock roughly correct.

Network protocols vs on-board protocols

Network protocols like TCP/IP move data between devices across networks. Inside a single device, chips talk over much simpler links such as UART, SPI, I2C and CAN. Those are covered in our guide to embedded communication protocols. A typical IoT product uses both: I2C to read its sensor, then TCP/IP over Wi-Fi to report the result.

The complete guide to architecture and hardware

Embedded System Architecture: Hardware and Software Components
Read the guide

Keep exploring

Guides from other topics

All topics →