How software systems agree on messages, exchange data, and work together. Explore networking, web APIs, security, messaging, real-time media, email and file transfer, operations, and developer tools through linked explanations and illustrations.
Also called: communication protocol, wire protocol
A protocol is an agreement about how participants communicate: which messages exist, how they are represented, what they mean, and what can happen next. An implementation is the software that follows those rules. Two programs can use different languages and operating systems while speaking the same protocol.
Imagine a small inventory service that accepts a lookup message and returns either a quantity or an unknown-item error. Agreeing on the message shape alone is insufficient: both sides also need to agree what the quantity measures and how failures are reported.
Also called: TCP/IP stack, Internet protocol suite
A protocol stack combines protocols with different responsibilities. In the Internet model, application protocols describe useful exchanges, transport protocols connect application endpoints, IP carries packets across networks, and link protocols move data across a particular local connection. These are cooperating layers, not four separate journeys.
One possible stack is HTTP/1.1 over TCP over IP over Ethernet. Other choices fit different needs: HTTP/3 uses QUIC over UDP. A stack diagram is a simplified map of responsibilities; it does not imply every application uses the same protocols or that every layer adds a fixed-size header.
Example without TLS. Each layer supplies a service to the layer above it. Data goes down the sender’s stack, across the one physical link, and up the receiver’s; the dashed peer relationships are logical.
Encapsulation places one protocol’s data inside another protocol’s message. The enclosing protocol adds information it needs, such as addresses, lengths, or control flags. The receiver interprets the enclosing structure before passing its payload to the appropriate next protocol.
For example, an IP packet can carry a TCP segment containing application bytes. A local link then carries that IP packet in its own frame. This nesting explains why a packet capture shows several headers for one exchange. Encapsulation alone does not hide the payload: encryption is a separate property.
Also called: message boundaries, length-prefix framing
Message framing tells a receiver where one message ends and the next begins. Common approaches include a length prefix, a delimiter with escaping rules, or a fixed message size. Framing matters when the underlying service delivers a stream of bytes without preserving the application’s write boundaries.
For DNS over TCP, a two-byte length precedes each DNS message and excludes those two bytes from the length. A receiver may need several reads to collect one message, or may receive pieces of several messages together. Correct framing reconstructs messages independently of how network reads happen to split the bytes.
Also called: serialisation, deserialization, encoding
Serialization turns structured data into a representation that can be stored or transmitted. Deserialization interprets that representation on the other side. A format such as JSON specifies how values are written; a protocol must additionally define what the fields mean and which messages are allowed.
For example, an application might encode a temperature reading as {"celsius":21} using UTF-8 JSON. The receiver still needs the agreement that this number is a temperature in Celsius. Serialization is neither encryption nor message framing, and converting an object to JSON does not automatically preserve every programming-language type.
A protocol state machine describes which events are valid in each state and how processing an event changes that state. Events can include received messages, application actions, and timers. The same incoming message may therefore require different handling before and after a connection is established.
Consider a hypothetical session with disconnected, connecting, and ready states. A successful handshake moves connecting to ready; a timeout returns it to disconnected. Drawing these transitions makes missing failure paths visible. Real protocols may have separate state machines for connections and individual streams, so a three-state sketch is only a teaching model.
Version negotiation lets peers determine a mutually supported set of protocol rules. A version number is useful only when the protocol also defines how peers advertise support, select a version, and handle an unsupported choice. Negotiating a protocol version differs from selecting an optional feature within one version.
In a hypothetical service, a client supports versions 2 and 3 while a server supports 1 and 2, so version 2 is their shared choice. With no overlap, the connection should fail in a defined way. Security-sensitive negotiation also needs protection against an attacker forcing an obsolete or weaker choice.
The end-to-end principle asks which functions need knowledge available only at the communicating endpoints. Lower layers can help, but they cannot always establish that the application’s full goal was achieved. Reliability and security checks may therefore still be required at the ends of a complete exchange.
For example, a file-transfer tool can compare a checksum of the saved file with one supplied by the sender. Successful packet delivery alone does not establish that the correct file reached durable storage. This is a design argument about responsibility, not a rule forbidding useful error detection or other assistance inside the network.
Type–length–value is a way to organize fields inside a message. The type identifies what a field represents, the length describes its size according to the format’s rules, and the value contains its data. A receiver can use those boundaries to locate the next field without understanding every value.
In a hypothetical format with one-byte type and length fields, type 05, length 03 and bytes 41 42 43 carry the three ASCII letters ABC. That whole field occupies five bytes. Real protocols must define field widths, byte order and what the length counts. An unknown type can be skipped only when that protocol’s rules permit it; lengths still need validation.
CBOR is a binary format for structured data, including integers, byte strings, text strings, arrays and maps. Encoded type information lets a decoder recognize these basic shapes without a separate schema. An application still needs a contract explaining what its fields mean and which values are acceptable.
For example, the array [1, 2, 3] can be encoded as the hexadecimal bytes 83 01 02 03: the first byte announces a three-element array, followed by the small integers. CBOR also supports tags that add agreed interpretation to values. Its compact representation does not provide encryption or automatically make two applications agree about the meaning of the data.
MessagePack is a binary serialization format for values such as integers, strings, arrays and maps. It provides compact encodings for small values and distinguishes text from arbitrary binary data. Extensions let applications assign additional types, but participants still need to agree on the meaning of those extension codes.
For example, [1, 2, 3] becomes the hexadecimal bytes 93 01 02 03: a fixed-size array header followed by three small integers. CBOR represents the same array with a different header, so the formats are not interchangeable. Choosing MessagePack does not by itself establish a message’s application schema, delivery guarantees or which operations a receiving service should perform.
Also called: Avro binary encoding, Avro writer schema
Apache Avro serializes structured data using a schema. Its binary record encoding follows the writer’s schema, so field names and type descriptions do not have to be repeated inside every encoded record. A reader must obtain that writer schema to interpret the bytes correctly.
For example, a record containing a person’s name and score can carry just the encoded values in schema order. An Avro object container file includes its writer schema in metadata; other arrangements can supply the schema separately. Avro also defines how a reader schema resolves against a writer schema, allowing certain differences. Keeping those two schemas distinct is essential when old and new services exchange records.
Also called: schema compatibility, backward-compatible schema, forward-compatible schema
Schema evolution changes the structure of exchanged data while managing compatibility between old and new software. Compatibility has a direction: can a new reader understand old data, and can an old reader handle new data? A rolling deployment may need both, because different versions coexist for a time.
In Protocol Buffers, adding a new field can preserve binary decoding while an older reader ignores the unfamiliar field. Reusing a deleted field number can instead give old bytes a different meaning, so removed numbers should be reserved. Even a wire-compatible change can break application assumptions. Teams must check required meaning and defaults, and distinguish binary compatibility from the rules of other representations such as JSON.
Also called: feature negotiation, capability exchange
Capability negotiation lets communicating programs discover which optional features they can use together. Version numbers alone may not reveal whether a particular implementation supports compression, streaming or a specialized operation. A protocol can exchange feature declarations and parameters, then define how to choose mutually usable behavior.
Imagine a client supporting compression and batching, while a server supports compression and streaming. Under a simple agreed selection rule, they can use compression but cannot assume the other two features. Real protocols must define defaults, required features and incompatible settings. DAP, for example, uses explicit capability flags for optional features. These declarations describe abilities; access to an operation still depends on separate authorization rules.
Also called: GREASE, Generate Random Extensions And Sustain Extensibility
Protocol greasing deliberately exercises extension points so implementations keep accepting unfamiliar but permitted values. Without it, deployed software can accidentally depend on seeing only today’s known options, making future additions fail. TLS GREASE reserves values that implementations can include in appropriate offers to expose this kind of accidental rigidity.
For example, a client can offer a reserved GREASE cipher-suite value alongside real supported suites. A compatible server ignores that unknown choice and selects an actual shared suite; it must not negotiate the GREASE value itself. This tests an existing extensibility rule using well-formed messages. It is not permission to ignore malformed data or unknown values in fields whose rules require rejection.
Also called: canonical encoding, JSON Canonicalization Scheme, JCS
Canonicalization gives data a precisely defined representation so independent systems can produce the same bytes. This matters when hashing or signing structured messages: whitespace or property order can change the bytes even when a reader interprets the same object. Both sides must use the same canonicalization rules.
For example, JSON objects written with b before a or with a before b can become the same canonical text under the JSON Canonicalization Scheme. JCS defines property ordering and number serialization while preserving array order; it does more than remove spaces. Its input constraints also matter, and it does not normalize Unicode strings. Canonical bytes support consistent verification but do not themselves prove who created the data.
Ethernet is a family of link-layer and physical-layer standards maintained by IEEE 802.3. It carries frames over links such as copper cables and optical fiber. A frame includes local source and destination MAC addresses, a payload, and a frame check sequence for detecting transmission errors.
For example, a laptop can place an IP packet inside an Ethernet frame addressed to its router. The router removes that frame and forwards the packet using an appropriate frame on the next link. Ethernet therefore handles a particular link’s delivery; IP handles travel between networks. Neither an Ethernet connection nor its error check automatically encrypts the payload.
Also called: media access control address, Ethernet address, EUI-48
A MAC address identifies a link-layer interface or destination group within technologies such as Ethernet. The familiar Ethernet form contains 48 bits, often written as six hexadecimal pairs. These addresses help deliver frames on a local network and are distinct from the IP addresses used for routing between networks.
For example, 02:00:00:00:00:25 is a locally administered, individual-address example. Its first byte marks it as locally assigned rather than universally assigned under an IEEE allocation. Software can change addresses, and privacy features can randomize them. A MAC address therefore should not be treated as permanent proof of a device’s identity or of its user.
Also called: Address Resolution Protocol, ARP cache
Address Resolution Protocol lets an IPv4 host discover the link-layer address needed to reach a next hop on a local network. On Ethernet, a host can broadcast a request naming the IPv4 address it needs; the matching host replies with its MAC address. The learned mapping is normally kept in a cache.
For example, a laptop sending to a distant website resolves its local router’s IPv4 address, then addresses the Ethernet frame to that router. It does not ask for the remote website’s MAC address. ARP exchanges stay on the local link and do not provide authentication by themselves. IPv6 uses Neighbor Discovery for this role.
Also called: NDP, ND, Neighbor Solicitation, Neighbor Advertisement
IPv6 Neighbor Discovery is a set of ICMPv6 mechanisms for finding neighboring nodes and routers, resolving link-layer addresses, and tracking whether neighbors remain reachable. Neighbor Solicitation and Neighbor Advertisement messages perform address resolution on links such as Ethernet. This covers the role of IPv4 ARP while also providing other local-network functions.
For example, a host needing a neighbor’s MAC address sends a solicitation to that neighbor’s solicited-node multicast address. The neighbor can advertise its link-layer address in reply. Router Solicitation and Router Advertisement support discovery of local routers and network parameters. These exchanges concern the local link; finding a router does not itself prove that a distant application is reachable.
Also called: Stateless Address Autoconfiguration, IPv6 autoconfiguration
Stateless Address Autoconfiguration lets an IPv6 host form addresses using local information and network prefixes advertised by routers. For an eligible advertised prefix, the host combines the prefix with an interface identifier and checks for duplicate use before treating the address as usable. Address lifetimes control how long it remains preferred and valid.
For example, a router advertising 2001:db8:1::/64 with autonomous configuration enabled can help a laptop form an address in that documentation prefix. The interface identifier need not expose the laptop’s MAC address; stable opaque identifiers are recommended. SLAAC can coexist with DHCPv6, while Neighbor Discovery supplies router information. “Stateless” does not mean that hosts remember no configuration.
Illustrative SLAAC workflow: an eligible advertised prefix and a host-generated interface identifier form an address that undergoes duplicate-address detection.
The maximum transmission unit, or MTU, is the largest network-layer packet that can be carried across a particular link without fragmentation. For IP, that size includes the IP header and its payload, but excludes the surrounding link-layer framing. Different links and tunnels can impose different limits.
For example, an IPv4 link with a 1,500-byte MTU can carry a 20-byte IPv4 header and up to 1,480 bytes of IP payload when no options are present. A TCP header consumes part of that payload too, so MTU is not the same as TCP’s maximum segment size. The smallest link MTU on a route constrains the path MTU.
Path MTU discovery estimates the largest IP packet that can traverse a route without fragmentation. The path MTU is limited by the smallest link MTU along that route. In IPv6’s ICMP-based method, a router unable to forward an oversized packet discards it and returns a Packet Too Big message naming the limiting MTU.
For example, a sender trying 1,500-byte packets may learn that a tunnel permits only 1,400 bytes and reduce its packet sizes. If those control messages are filtered, traffic can stall despite smaller packets succeeding. Packetization-layer methods instead use probes and delivery feedback to discover usable sizes without depending on ICMP delivery. Path changes can require a new estimate.
Network byte order commonly means representing a multi-byte integer with its most significant byte first, also called big-endian order. Agreeing on byte order lets machines with different internal representations interpret the same wire value. A protocol’s specification still decides its encoding; not every binary protocol uses this convention.
For example, the 32-bit hexadecimal value 0x01020304 is transmitted as the byte sequence 01 02 03 04 in big-endian order. Reading those bytes as little-endian would produce a different value. Byte order describes the arrangement of whole bytes, not the electrical order of bits on a cable. Libraries commonly provide conversion or packing operations for this boundary.
Internet Protocol, or IP, carries datagrams between addressed endpoints across interconnected networks. Routers forward packets toward a destination using routing information. IP supplies a common delivery layer even when the links along the way use different technologies.
Imagine a request travelling from a laptop through a home router and an access provider to a server. IP helps each hop move the packet onward, but does not itself guarantee delivery, ordering, or retransmission. Applications needing an ordered stream can use a transport such as TCP above IP. IPv4 and IPv6 are different versions of this network-layer protocol.
IPv4 is the Internet Protocol version whose addresses contain 32 bits. The familiar dotted-decimal notation writes those bits as four numbers from 0 to 255. Packets carry source and destination addresses along with fields used for forwarding and packet handling.
For example, 192.0.2.25 is a documentation address written as four eight-bit groups. The notation does not identify a permanent person or device: interfaces can have multiple addresses, and assignments can change. IPv4’s finite address space helped motivate address sharing through NAT and the larger address space of IPv6.
IPv6 uses 128-bit addresses and a different packet format from IPv4. Addresses are normally written in hexadecimal groups separated by colons; a double colon can abbreviate one run of zero groups. The larger address space supports many more distinct addresses, but does not itself provide encryption.
The documentation address 2001:db8::25 expands to eight groups of four hexadecimal digits. IPv6 routers do not fragment packets in transit; the source handles fragmentation when needed. Applications supporting both IP versions must account for their distinct address families rather than treating IPv6 as a longer IPv4 string.
Also called: subnet, CIDR, prefix length, subnet mask
An IP address identifies a network-layer endpoint; a prefix describes a block of addresses sharing leading bits. In slash notation, the number after the slash counts those shared bits. Subnets use address prefixes to organize local networks and inform forwarding decisions.
For example, 192.0.2.64/26 contains 64 IPv4 addresses, from 192.0.2.64 through 192.0.2.127. There are six remaining address bits because 32 − 26 = 6. That is a block size, not a promise of 64 usable host assignments: reserved addresses and deployment rules affect which addresses can be assigned.
Also called: IP routing, packet forwarding, longest-prefix match
Routing establishes how network destinations can be reached; forwarding applies that information to individual packets. A router’s forwarding table maps destination prefixes to next hops or outgoing interfaces. Routes may be configured manually or learned through routing protocols.
When both 192.0.2.0/24 and 192.0.2.64/26 match destination 192.0.2.70, ordinary destination-based IP forwarding selects the more specific /26 entry. A default route matches when no more specific entry applies. This longest-prefix choice does not mean that every router knows a packet’s entire future path or chooses the geographically shortest journey.
Also called: Internet Control Message Protocol, ICMPv6, ping
Internet Control Message Protocol carries network control and diagnostic messages alongside IP traffic. Examples include destination-unreachable reports, time-exceeded reports, and echo requests and replies used by ping. IPv4 and IPv6 use different ICMP versions and message formats.
If a router discards a packet after its hop limit expires, an ICMP time-exceeded message can help the sender understand what happened. These reports do not make IP reliable, and their absence does not prove that a destination is healthy or broken: messages may themselves be filtered or lost. ICMP is not a TCP or UDP port-based service.
Also called: NAT, NAPT, port address translation, PAT
Network address translation changes IP addresses as packets cross a network boundary. A common variant also translates transport ports, allowing several private-network endpoints to share one public IPv4 address. The translator keeps mappings so replies can be sent back to the appropriate internal endpoint.
For example, 10.0.0.8:5000 might be mapped to 203.0.113.9:62001 for an outbound TCP connection. The reply uses the mapping in reverse. This changes address visibility and can complicate incoming connections; it does not encrypt payloads or replace an explicit firewall policy. The public-side address here is a documentation example.
Also called: Dynamic Host Configuration Protocol, DHCPv4, address lease
Dynamic Host Configuration Protocol helps a host obtain network configuration. In DHCP for IPv4, a server can lease an address and supply settings such as a subnet mask, router, and DNS servers. A lease gives the client permission to use an address for an agreed period, rather than permanently assigning it.
A typical new-client exchange is Discover, Offer, Request, Acknowledge. For example, a laptop may accept a lease for 10.0.0.20 and later renew it before expiry. This four-message sketch describes a common initial allocation, not every DHCP exchange. DHCPv6 has a separate message design, and IPv6 also supports other configuration mechanisms.
Border Gateway Protocol exchanges reachability information between autonomous systems: networks that present a coordinated routing policy to their neighbors. BGP advertisements describe reachable IP prefixes and attributes such as the autonomous-system path. Operators use these attributes and local policies to decide which routes to select and advertise onward.
For example, a network can learn two routes to a prefix through different providers and prefer one because of its commercial policy. That choice need not be the shortest geographic journey or the path with the fewest routers. BGP distributes routing information; ordinary IP forwarding then uses the resulting routes to move individual packets. Its basic advertisements do not by themselves establish that every routing claim is trustworthy.
An autonomous system, or AS, is a collection of IP networks and routers that presents a coherent routing policy to other networks. Its autonomous system number identifies it in interdomain routing, including BGP paths. The useful boundary is routing administration and policy, rather than a building, subnet, or individual router.
For example, an access provider may operate routers across many cities while advertising its prefixes as one AS. Another organization may operate multiple autonomous systems because it has separate routing needs. Inside an AS, an interior routing protocol can determine internal paths; BGP communicates reachability across AS boundaries. The number describes a routing participant, not the ownership or trustworthiness of every packet it forwards.
Also called: Open Shortest Path First, OSPFv2, OSPFv3, link-state routing
Open Shortest Path First is a link-state routing protocol used within an autonomous system. Routers exchange information about links and maintain a topology database for their area. Each router calculates routes from that shared view using accumulated link costs. Areas limit how much detailed topology must be distributed throughout a larger deployment.
For example, a two-link route with costs 2 and 2 beats a route with costs 1 and 6 because its total cost is 4 rather than 7. Cost is a configured routing metric, not necessarily geographic distance or a count of hops. OSPFv2 serves IPv4; OSPFv3 introduced IPv6 support. BGP addresses the separate problem of routing between autonomous systems.
Anycast makes the same service address reachable from multiple locations. Routers direct a packet toward one of those locations using their routing information and policy. This can distribute demand and offer alternative destinations when routes change, without requiring clients to choose a different service IP address.
For example, two DNS sites can announce routes for the same service address, and a resolver’s query reaches whichever site its network’s route selects. “Nearest” means preferred by routing, not necessarily closest on a map. Packets are not copied to every site. Route changes can also move traffic between locations, so applications with long-lived connections or shared state need to account for that possibility.
Also called: DNS time to live, record TTL, DNS cache expiry
A DNS time to live, or TTL, specifies how many seconds a record may normally remain in a cache before fresh information is needed. A caching resolver reduces the remaining lifetime as time passes. The TTL concerns cached DNS data; it is separate from the hop-limiting field used in IP packets.
For example, a record cached with a TTL of 300 seconds has about 180 seconds remaining two minutes later. Changing the authoritative record does not instantly invalidate copies already cached elsewhere. TTL is therefore not a universal countdown for a DNS change to finish “propagating.” Under configured serve-stale behavior, a resolver may temporarily answer with expired data when attempts to refresh it fail.
Also called: DNS Security Extensions, DNS validation, DNS signatures
DNS Security Extensions let a validating resolver check the origin and integrity of DNS data using digital signatures. Signed record sets, DNS keys, and delegation records establish a chain from a configured trust anchor to the requested data. DNSSEC can also authenticate a denial that a requested name or record exists.
For example, a resolver checking an address record can verify its signature and the key’s chain of trust before accepting the signed answer. A signature mismatch is a validation failure, not an alternative address to trust. DNSSEC does not encrypt queries or answers, and a valid signature does not prove a website is harmless. DNS transport encryption solves a different problem.
DNS over HTTPS, or DoH, carries DNS queries and answers inside HTTPS exchanges. It protects the connection between a client and its selected DoH resolver using TLS, including authentication of that HTTPS endpoint. The DNS message retains its DNS meaning even though HTTP provides its transport envelope.
For example, a browser can send an encrypted query to a configured resolver rather than sending a plain DNS request across the local network. That resolver still receives the query and can observe the names being requested. Encryption of this hop does not automatically protect every later DNS exchange or validate DNSSEC signatures. Resolver selection, DNS data authentication, and transport privacy remain distinct decisions.
Also called: DoT, DNS privacy, encrypted DNS over TLS
DNS over TLS, or DoT, carries DNS messages over a dedicated TLS-protected connection, normally using TCP port 853. After establishing TLS, the client and resolver exchange DNS messages with length framing. Authenticating the resolver is essential when the client requires protection against an active attacker impersonating it.
For example, a device can keep a TLS connection open to its configured recursive resolver and send several queries through it. A local network observer cannot simply read those DNS messages, but the chosen resolver still can. DoT protects that connection; it does not encrypt the entire recursive lookup chain or replace DNSSEC validation. DoH carries DNS through HTTPS instead of this dedicated transport.
Also called: Transmission Control Protocol, byte stream
Transmission Control Protocol provides an ordered byte stream between two endpoints. Sequence numbers, acknowledgments, and retransmission recover from many packet losses while a connection remains usable. TCP does not preserve the boundaries of individual application writes, and it does not itself encrypt the stream.
If a sender writes “HELLO” and then “WORLD”, the receiver might read “HEL”, then “LOWORLD”. The bytes remain ordered, but application-level framing must identify messages. A successful write also does not prove that the peer application processed or saved the data. Broken connections still need error handling at the application level.
A TCP handshake synchronizes connection state and initial sequence numbers before normal data exchange. The usual three-way opening sends SYN, then SYN plus ACK, then ACK. Each side’s SYN consumes one sequence number; an acknowledgment identifies the next sequence number expected from the peer.
With illustrative starting numbers 1000 and 7000, the exchange is SYN 1000, SYN 7000 with ACK 1001, then ACK 7001. This explains the extra one without counting application bytes. The handshake establishes a transport connection; it does not authenticate a website or negotiate encryption. TLS performs a separate security handshake when used.
Also called: User Datagram Protocol, datagram transport
User Datagram Protocol sends separate messages, called datagrams, between application endpoints identified by ports. It adds relatively little machinery above IP. UDP itself does not guarantee delivery, ordering, duplicate suppression, retransmission, or congestion control, and it does not establish a TCP-style connection.
An application sending numbered sensor readings may receive readings 12 and 14 while 13 is lost. It must decide whether to request the missing reading or continue with newer information. Protocols built on UDP can add reliability and security, as QUIC does; choosing UDP therefore does not determine all the properties of the complete application protocol.
QUIC is a transport protocol carried in UDP datagrams. Its core design combines secure connection establishment, reliable streams, flow control, and congestion control. QUIC version 1 integrates TLS for its cryptographic handshake; using UDP underneath does not mean the application receives an unreliable or unencrypted stream.
Multiple streams can share one connection. If data is missing on one stream, that gap need not block delivery of available data on another stream. Each stream still has its own ordering, and all streams share connection and network constraints. HTTP/3 uses QUIC, but QUIC is not limited to carrying HTTP.
Also called: Domain Name System, DNS records, A record, AAAA record
The Domain Name System is a distributed naming system whose records associate names with information. Address records are one familiar use: A records contain IPv4 addresses and AAAA records contain IPv6 addresses. Other record types identify mail servers, aliases, or additional data.
An application can look up api.example.com before connecting to a service. The name may have several addresses, and those answers may change. DNS does not fetch the web page or prove that a responding application is trustworthy. Resolving a name and making an authenticated connection are different steps in the application’s work.
Also called: recursive resolver, iterative DNS lookup, DNS cache
DNS resolution is the process of finding an answer to a DNS question. A recursive resolver may answer from its cache or consult other servers. In a simplified uncached lookup, root servers point toward a top-level domain, which points toward the authoritative servers responsible for the requested name.
For www.example.com, a resolver may follow referrals through the root and .com before receiving an authoritative answer. The client need not make those queries itself. Cached answers can avoid these steps until their allowed lifetime expires; aliases and other circumstances can add further queries. The drawn sequence is a teaching example, not a fixed number of network trips.
Also called: receive window, receiver flow control, credit-based flow control
Flow control prevents a sender from overwhelming the receiver’s available capacity. In TCP, the receiver advertises a receive window that limits how much additional stream data may be outstanding relative to the acknowledged position. Other protocols can express permission using credits or per-stream limits.
Imagine a receiver with room for four more equal-sized chunks. It can advertise that allowance, then increase it as the application consumes buffered data. The sender must also respect congestion control, which protects the network path. A large receive window therefore does not imply the network can sustain an equally large sending rate.
Also called: congestion window, cwnd, network congestion
Congestion control adapts traffic to the capacity of the network path. Senders use signals such as acknowledgments, loss, delay, or explicit congestion marks to decide how much data to keep in flight and when to send it. The aim is useful delivery without persistently overloading shared links.
If several senders converge on one slower link, its queue can grow and packets can be dropped. A sender that reduces its load gives that queue a chance to drain. Algorithms differ in how they probe and respond. This is distinct from flow control: the receiver may have plenty of memory while a router along the path is overloaded.
Also called: port number, TCP port, UDP port, ephemeral port
A transport port is a numbered field that helps an operating system direct network traffic to the appropriate endpoint. TCP and UDP use 16-bit source and destination ports, with separate namespaces for each transport. An IP address identifies a network endpoint; a port helps distinguish services or conversations at that endpoint.
For example, a client might connect from TCP port 51000 to a server’s TCP port 443. The reply reverses those port roles, while other connections can use different address-and-port combinations. Familiar port assignments are conventions, not proof of what an application really does. Traffic on port 443 is not automatically trustworthy or encrypted merely because that number appears in its header.
Also called: network socket, listening socket, connected socket, socket API
A socket is a software endpoint through which an application uses communication services supplied by the operating system. Its address family and type determine how it behaves: an Internet stream socket commonly uses TCP, while a datagram socket commonly uses UDP. A socket is an API object, not a physical connector or just a port number.
For example, a TCP server binds a listening socket to a local address and port, then accepts an incoming connection. The accept operation returns a separate connected socket used to exchange bytes with that client. The listening socket can continue accepting other clients. Several connections can share the server’s port because their complete endpoint combinations distinguish them.
Also called: Internet checksum, error detection, checksum verification
A checksum is a compact value calculated from data to help detect accidental corruption. The receiver recomputes or verifies the value and compares the result with what the sender supplied. Internet protocols use several error-detection schemes; the Internet checksum used by TCP and UDP is a particular 16-bit arithmetic construction.
For example, a bit damaged during transmission may cause the received bytes to fail checksum verification. Some patterns of changes can still escape detection because many possible messages share the same small checksum. An attacker who can rewrite a message can also recalculate an ordinary checksum. Detecting accidental errors is therefore different from cryptographic integrity protection, which is designed to resist deliberate modification.
Simplified one-word Internet-checksum example: 0A3C has checksum F5C3. Changing the word to 0A3D fails verification with that unchanged checksum. Real protocol checks include additional fields.
Also called: fragmentation, IP reassembly, fragment offset, DF flag
IP fragmentation divides one datagram into smaller fragments so they can cross a link’s size limit. Each fragment carries information that lets the destination reconstruct the original datagram. IPv4 routers can fragment when permitted by the packet’s flags; IPv6 routers do not, so IPv6 fragmentation is performed only by the source.
For example, an IPv4 datagram with a 20-byte header and 2,000-byte payload can become fragments carrying 1,480 and 520 payload bytes across a 1,500-byte MTU link. Each fragment has its own header. Losing one fragment prevents complete reassembly unless the missing information is recovered through another mechanism. Path MTU discovery helps senders avoid needing IP fragmentation in the first place.
TCP selective acknowledgment, or SACK, lets a receiver report ranges of bytes that arrived beyond a gap in the ordered stream. Ordinary cumulative acknowledgments still identify the first byte not yet received in sequence. The extra range information helps the sender identify missing data and recover losses without unnecessarily retransmitting every later byte.
For example, if bytes 2,000–2,999 are missing but 3,000–3,999 arrived, the receiver can send cumulative ACK 2000 plus a SACK block [3000, 4000). The block’s right edge names the byte after the received range. SACK support is negotiated during connection setup. Acknowledging later bytes does not allow the application to bypass TCP’s in-order delivery requirement.
Also called: HOL blocking, head of line blocking, TCP head-of-line blocking
Head-of-line blocking occurs when an early item prevents later work from progressing even though that later work is otherwise ready. In an ordered transport stream, missing bytes must arrive before subsequent bytes can be delivered in order. Multiplexing application messages does not automatically remove this dependency from the underlying transport.
For example, HTTP/2 can interleave several responses over one TCP connection, but a missing TCP segment can delay delivery of later bytes belonging to multiple responses. QUIC gives streams independent delivery ordering, reducing this blocking across streams. A stream still waits for its own missing bytes, and losing one packet containing several streams can affect all of them. Independence does not eliminate every shared bottleneck.
Also called: TCP keep-alive, keepalive probe, idle connection probe
TCP keepalive is an optional mechanism for probing an idle connection to see whether the remote TCP endpoint still responds. After a configured idle interval, the local stack sends a probe designed to elicit a reply. Applications can enable or disable the mechanism, and timing policies vary across implementations and deployments.
For example, a database client may use keepalive to eventually detect a peer that disappeared while no queries were being sent. One unanswered probe alone does not establish a dead connection. Conversely, a reply only demonstrates a responsive TCP endpoint: the database application might still be stuck. TCP keepalive is distinct from an application heartbeat and from HTTP connection reuse sometimes called keep-alive.
Also called: 0-RTT, zero round-trip time, TLS early data, early data
Zero round-trip time early data lets a client send application data before waiting for a new handshake response, using an eligible pre-shared key. In TLS 1.3 this often comes from a previous connection. It can reduce startup latency, but early data has weaker security guarantees than ordinary post-handshake data, especially around replay.
For example, a returning client might send an eligible catalog lookup immediately, while a purchase operation waits for the handshake. Which requests are acceptable depends on the application’s replay policy, not just their HTTP method. Early data is encrypted, yet recorded requests may be replayed unless appropriate defenses prevent or safely handle duplicates. A server can reject early data; “zero” does not mean zero network delay.
HTTP is an application protocol for asking a server to act on an identified resource and interpreting its response. A request carries a method, a target and fields; the response carries a status, fields and sometimes content. HTTP versions preserve these meanings while changing how messages travel.
For example, a glossary reader requests GET /terms/tcp; the server can return 200 with an HTML explanation. The same interface can serve JSON or images. HTTP is stateless at the protocol level: applications can still remember sessions through mechanisms such as cookies.
An HTTP method states the operation a client requests. GET retrieves a representation; POST asks a resource to process submitted content; PUT supplies a desired replacement state; DELETE requests removal of the target resource’s association. PATCH describes a partial modification under its own rules.
In a hypothetical notes API, GET /notes/7 reads a note while PUT /notes/7 replaces it. The method is part of the contract, not simply a convenient verb in a URL. Servers must implement that meaning consistently so clients and intermediaries can handle requests correctly.
Hypothetical notes API: GET reads, this POST creates, PUT replaces, and DELETE removes the resource association. POST behavior is application-defined; deletion need not erase every stored copy.
An HTTP status code is a three-digit summary of a response. The first digit groups it into information (1xx), success (2xx), redirection (3xx), a request problem (4xx), or a server problem (5xx). The precise code and accompanying fields explain what happened.
For a hypothetical file API, 201 Created can report a newly created file, while 404 Not Found says no current representation was found or disclosed. A 202 Accepted response means processing was accepted, not that the job finished. Clients should inspect the documented response rather than treating every 2xx code identically.
The first digit identifies a status family. A 304 response is in the 3xx family without redirecting to a new URL. A 202 response accepts work but does not prove it has finished.
Also called: HTTP fields, request headers, response headers
HTTP headers are named fields that carry metadata and control instructions with a request or response. They can describe content, express preferences, carry credentials or guide caching. Field names are case-insensitive, though their encoding and some naming requirements depend on the HTTP version.
For example, a client’s Accept: application/json states a response preference, while the server’s Content-Type: application/json describes the content it actually sends. These fields play different roles. A header is not the message body, and adding a familiar field name does not make an application enforce its meaning automatically.
Accept expresses the client’s preferred response format. Content-Type describes the returned content, while the JSON body occupies a separate part of the message.
Also called: HTTP method safety, read-only methods
A safe HTTP method asks for essentially read-only behavior: the client is not requesting a change to the resource’s state. GET and HEAD are common examples. Incidental effects such as access logs can still happen. Safety describes the requested operation, not encryption, authorization or freedom from software bugs.
Imagine a link preview fetching GET /invoices/8. It should retrieve information without approving the invoice. An endpoint that approves it merely because a crawler follows the link violates this expectation. PUT and DELETE are not safe, even though their intended effects are idempotent when implemented correctly.
Reading the draft invoice with GET leaves its intended resource state unchanged. A separate approval action changes that state and is unsafe in HTTP’s sense; incidental logging may still occur during reads.
Also called: idempotent operation, idempotent methods
An operation is idempotent when repeating the same request has the same intended effect as performing it once. In HTTP, safe methods, PUT and DELETE have this property by definition. It does not require identical responses, identical logs, or an unchanged world between attempts.
For example, setting a note’s title to “Network notes” twice leaves that title in place. Appending another copy of a note twice may create two copies. Idempotency helps recover from an unknown outcome after a connection failure; retries still need sensible limits and must respect the actual operation’s contract.
Setting the same title once or twice has the same intended final effect. This illustrative append operation adds another copy each time. Idempotency concerns effects, not identical response codes.
Also called: representation negotiation, Accept, Vary
Content negotiation chooses a representation of a resource using information such as acceptable media types, languages or content encodings. In server-driven negotiation, request fields such as Accept or Accept-Language provide preferences; the server chooses among the representations it can supply.
A hypothetical report endpoint might return JSON to one client and HTML to another at the same URL. The response’s Content-Type identifies the chosen form. When selection depends on a request field, Vary tells caches to account for it. Preferences do not guarantee that every requested format is available.
Two representations of the same hypothetical report. Accept guides selection; Vary: Accept tells a cache to account for that request field when matching stored responses.
Also called: HTTP preconditions, ETag, If-Match, If-None-Match
A conditional HTTP request includes a precondition that the server evaluates before applying the operation. Validators such as entity tags, or ETags, identify a representation’s version. Conditionals can avoid transferring unchanged content or prevent an edit from silently overwriting someone else’s update.
Suppose two editors read revision "r4". One saves a change that produces "r5". The other sends PUT with If-Match: "r4"; the server can reject the stale edit with 412. For caching, GET with If-None-Match can instead receive 304 when the stored representation remains usable.
Both editors read ETag “r4”. A’s save produces “r5”; B’s later If-Match: “r4” fails with 412, preserving A’s revision. These labels are illustrative opaque entity tags.
Web transports and browser rules
How HTTP versions, secure connections, caches and browsers shape delivery.
HTTP/1.1 defines a textual message format and connection rules for HTTP exchanges. A start line and header lines precede any body; framing rules identify where that body ends. Connections can be reused for multiple exchanges, avoiding a fresh connection for every resource.
Imagine requesting a large image and then a small stylesheet on one connection. Even with pipelined requests, HTTP/1.1 responses must arrive in request order, so the stylesheet can wait behind the image. Browsers can use additional connections for concurrency. The protocol version changes message handling without changing what GET or a 404 response means.
Illustrative pipelining on one HTTP/1.1 connection. The stylesheet response follows the earlier image response even if it is ready sooner. Pipelining is possible, not universal client behavior.
HTTP/2 carries HTTP messages in binary frames and multiplexes several exchanges on one TCP connection. Stream identifiers keep the exchanges distinct, and compressed fields reduce repeated metadata. A server can interleave data from different responses instead of finishing one whole response before starting the next.
For example, frames for an image and stylesheet can alternate while both resources load. This removes HTTP/1.1’s response-order bottleneck, but TCP still delivers one ordered byte stream: a missing TCP segment can hold up bytes belonging to several HTTP/2 streams. Multiplexing therefore improves concurrency without eliminating every source of waiting.
HTTP/2 frames from different streams share a TCP connection. Their interleaving avoids HTTP/1.1 response ordering, but a missing TCP segment can delay delivery of later bytes from either stream.
HTTP/3 maps HTTP exchanges onto QUIC rather than TCP. QUIC runs over UDP and provides reliable streams with integrated security. An HTTP request and its response share a bidirectional QUIC stream; separate streams can make progress without waiting for each other’s missing stream data.
If one image loses a packet, an unrelated stylesheet stream need not wait for that image’s retransmission as it would behind TCP’s single ordered byte stream. Loss still consumes time and can affect shared congestion control or application dependencies. HTTP/3 retains familiar HTTP meanings; it does not make requests unreliable merely because UDP carries QUIC packets.
A gap delays the affected QUIC stream, while another stream can deliver available data. QUIC supplies reliability above UDP; the streams still share connection and congestion constraints. Timing is schematic.
HTTPS is HTTP communication protected using TLS security. It provides confidentiality and integrity for traffic and authenticates the server for the requested authority when certificate validation succeeds. HTTP/1.1 and HTTP/2 commonly use TLS over TCP; HTTP/3 uses QUIC’s integrated TLS-based security.
When a reader opens https://glossary.example/, network observers should not see the article text or alter it undetected in transit. The server still sees the request, and some connection metadata remains visible. A protected connection does not establish that the site’s claims are true or that its operator is trustworthy.
HTTP is readable at its endpoints and protected in transit. Endpoint authentication and payload protection do not hide every connection detail or establish the truth of the server’s content. HTTP/3 integrates TLS-based security with QUIC.
An HTTP cache stores responses and reuses them when protocol rules permit. Private caches usually serve one user; shared caches serve multiple clients. Freshness, validators and request matching decide whether a stored response can be reused, checked with the origin, or replaced.
A hypothetical public glossary response with Cache-Control: max-age=60 can remain fresh for sixty seconds of age, subject to other rules. After freshness expires, a validator may avoid downloading the whole article again. The directive no-cache requires validation before reuse; no-store directs caches not to store the response. Those names have different meanings.
A hypothetical cacheable response is fresh until age 60 seconds. A request at age 20 reuses it; a later request revalidates in this example. Freshness expiry is not an eviction deadline. No-cache and no-store have different rules.
Also called: browser cookies, Set-Cookie, session cookie
A cookie is a small piece of state a browser stores and sends with eligible later requests. A server can set it using Set-Cookie; the browser’s Cookie field carries the stored name and value. Domain, path, lifetime and other rules determine when it is included.
For a hypothetical signed-in session, the browser stores an opaque session identifier, while the server associates that identifier with an account. Secure restricts sending to secure transport, HttpOnly restricts script access, and SameSite limits certain cross-site sending. These attributes address different risks; a cookie itself is neither encryption nor proof that the current holder is authorized.
A fictitious opaque cookie value links eligible browser requests to server-side session data. Secure, HttpOnly, and SameSite govern different behaviors; the cookie is not the server’s session record or encryption.
Also called: Cross-Origin Resource Sharing, CORS preflight, same-origin policy
Cross-Origin Resource Sharing is a browser-enforced protocol that lets a server declare which origins may read a response through web APIs. An origin is defined by scheme, host and port. Response fields such as Access-Control-Allow-Origin express permission; some requests first require an OPTIONS preflight.
A page at https://app.example might fetch data from https://api.example. The API’s response must satisfy CORS checks before the browser exposes it to that page’s script. CORS is not user authorization or a general firewall: some requests can be sent without preflight, and non-browser clients do not enforce the browser’s same-origin restrictions.
The browser checks the API response before exposing it to the page’s script. Some requests first require a preflight; failed CORS checks do not imply that every request was stopped before reaching the API. Authorization remains separate.
Also called: forward proxy, reverse proxy, HTTP proxy
A web proxy is an intermediary in a request’s path. A forward proxy acts for clients reaching other servers; a reverse proxy presents a service to clients and forwards work to backend servers. Proxies can route traffic, distribute load, cache responses or apply access rules.
For a hypothetical glossary service, a reverse proxy at the public address sends requests to two application servers. If it terminates TLS, it can read the decrypted HTTP exchange; a separate connection may protect the backend hop. A tunnel can instead relay encrypted traffic without interpreting its HTTP content. Placement and configuration determine the trust boundaries.
Forward proxies act for clients; reverse proxies front a service. The reverse-proxy example terminates client TLS and uses separate protected backend connections. Other proxy configurations, including tunnels, differ.
HTTP authentication provides a framework for presenting credentials and challenging a request. An origin server can return 401 with WWW-Authenticate; the client can send credentials in Authorization. The named scheme determines how those credentials work. Supplying credentials does not automatically grant permission to every resource.
For example, a document service challenges a request with WWW-Authenticate: Bearer, and a client retries with its access token. Basic authentication instead encodes a username and password using Base64, which provides no secrecy. HTTPS protects transport; the authentication scheme and the service’s permission checks still have separate jobs.
An HTTP 401 challenge names a scheme. The client supplies a token in a later request; access still depends on credential validation and permission checks.
Also called: bearer credential, OAuth bearer token
A bearer token is a credential whose possession is sufficient to use the authority it represents, subject to server validation. The holder need not prove possession of a separate cryptographic key. “Bearer” describes how a token is used; JWT describes a possible token format. An opaque random string can also be a bearer token.
For example, a photo client sends Authorization: Bearer ... when reading an album. Someone who steals that usable token may exercise its allowed access until it expires or is rejected. TLS protects it in transit, while scopes and expiry limit its authority; decoding a JWT does not establish whether it is valid.
Opaque strings and JWTs can both be used as bearer credentials. Possession supplies the credential; the server must still validate it and enforce the limited permission it grants.
A range request asks for part of a representation, which helps resume downloads or seek within large files. With byte ranges, positions start at zero and the ending position is inclusive. A server that honors the request returns 206 Partial Content and identifies the returned range; support is not guaranteed.
For a 1,000-byte file, Range: bytes=200-399 asks for 200 bytes. A matching response carries Content-Range: bytes 200-399/1000. A server can ignore the range and send the full file with 200, or reject an unsatisfiable range with 416. An If-Range validator helps a client avoid combining pieces from different versions.
Honored-range example: positions 200 through 399 inclusive contain 200 bytes, one fifth of the 1,000-byte file. A server can instead ignore the range or reject an unsatisfiable request.
Rate limiting controls how much activity a caller may perform over time. An HTTP service can signal a limit with 429 Too Many Requests and may supply Retry-After. The quota might apply to an account, token, address or resource; HTTP does not prescribe a universal counting algorithm.
Imagine an export API allowing an account ten starts per minute. An eleventh request receives 429 with Retry-After: 20, asking the client to wait twenty seconds before trying again. Waiting does not reserve future capacity. Clients also need retry limits and safe retry behavior, because a quota response and an uncertain earlier request are different situations.
The eleventh request exceeds this hypothetical account quota. Retry-After: 20 asks the client to wait twenty seconds; it does not promise success or reserve capacity.
Problem Details is a standard format for describing HTTP API errors beyond a status code. A JSON response uses application/problem+json. Its type identifies the kind of problem, title summarizes it, detail explains this occurrence, and instance can identify that occurrence. APIs may add documented extension fields.
For example, a report request might return 422 with a documented “invalid-date-range” type and a detail explaining that the end precedes the start. Software should use stable identifiers or structured extensions rather than parse the human explanation. If the body includes status, the origin must match it to the actual HTTP status; sensitive debugging data belongs elsewhere.
A hypothetical Problem Details response has a type URI for software and detail text for people. Its body status matches the actual 422 response; the shown URI is a documentation example.
Pagination divides a collection response into smaller pages. An API may use page numbers, offsets, continuation tokens or links to navigate them. This is an API design pattern, not one universal HTTP protocol: callers must follow the service’s documented ordering, parameters and rules for detecting the end.
For example, a catalogue returns twenty results plus an opaque continuation token. The client sends that token back with the same filters to request the next batch, without interpreting its contents. Another API may provide a Link header with rel="next". A continuation token is a navigation handle, not permission to read records; authorization still applies to every request.
This example returns twenty results, then seven final results. The next request returns T1 unchanged, preserves the query, and passes authorization again. The token is a navigation handle, not a credential.
An HTTP redirect asks the client to make another request, usually to the address in Location. Status codes communicate whether the move is temporary or permanent and how the method is handled. A 307 or 308 preserves the method and body; 303 points to a retrieval request. Historical 301 and 302 behavior can change POST to GET.
For example, after accepting a submitted form, a server can return 303 pointing to a receipt that the browser fetches with GET. A permanent move of an API operation may use 308 when preserving the method matters. Redirects add requests and can form loops; not every 3xx response redirects to another address.
Two example redirect flows: 303 leads from POST to a GET receipt; permanent 308 keeps POST and the same body at the new API location. Each arrow represents a later exchange, not an internal server rewrite.
CONNECT asks a proxy to establish a tunnel to a destination. In the classic HTTP/1.1 form, the target is a host and port. After a successful response, the proxy forwards bytes in both directions rather than interpreting them as ordinary HTTP request bodies. The tunnel itself does not provide encryption.
For example, a client sends CONNECT archive.example:443 to its proxy. Once the proxy confirms the tunnel, the client can perform TLS with the archive server through it, keeping that TLS connection’s endpoints at the client and archive. Proxy policy still controls which destinations are allowed. Extended CONNECT mechanisms for newer HTTP versions have additional, separately specified rules.
Classic HTTP/1.1 CONNECT first creates a byte tunnel. The client can then negotiate TLS through it with the archive server; this forwarding proxy is not a TLS endpoint, and the tunnel alone is not encryption.
API styles and contracts
Architectural choices, callable services, schemas and integration contracts.
Also called: Representational State Transfer, RESTful architecture
REST is an architectural style for distributed hypermedia systems, rather than a single wire protocol or a synonym for JSON APIs. Its constraints include client–server separation, stateless interaction, cacheability, a uniform interface and layers; executable code sent to clients is optional. Resources are manipulated through representations.
A hypothetical order representation can include its current status and a link to the available cancellation action. The client follows that advertised transition using the interface’s defined semantics. Merely naming paths /orders and exchanging JSON does not establish every REST constraint. Statelessness concerns request context; it does not prohibit storing resource data.
A hypothetical order representation advertises an available cancellation transition. The client uses that link and receives a new representation. This illustrates hypermedia within REST’s broader architectural constraints, not a full definition of REST.
A remote procedure call presents an operation in another process as a callable service method. The client encodes a method selection and arguments into a request; the server executes the operation and returns a result or error. RPC is a model used by many protocols, including gRPC and JSON-RPC.
An inventory client might call reserveItem(42) through a generated stub. Unlike a local call, it can fail because of a network break or deadline. If the reservation succeeded but its response was lost, the caller may not know the result. The interface therefore needs explicit rules for retries and duplicate effects.
An RPC crosses a network through a client stub and server method. In the alternate lost-response path, the server saved the reservation but the caller cannot tell from its missing response whether it succeeded.
gRPC is an RPC framework with a defined protocol, commonly using HTTP/2 and Protocol Buffers. A service definition specifies callable methods and message types; generated client and server code connects those definitions to application logic. Calls can be unary, client-streaming, server-streaming or bidirectional-streaming.
For a hypothetical telemetry service, WatchSensor can accept one sensor identifier and return a stream of readings. Each call also has status and may have metadata and a deadline. A client deadline expiring does not prove that the server performed no work, and cancellation does not undo changes already made.
The four gRPC call patterns count application messages, not packets. WatchSensor illustrates server streaming; bidirectional call streams can progress independently while preserving each direction’s message order.
Also called: Protobuf, proto schema, protobuf serialization
Protocol Buffers, or Protobuf, provides a schema language, generated code and a binary serialization format for structured messages. A .proto definition gives fields types and stable numeric identifiers. It can encode data for a network exchange or a file; it does not establish a connection or deliver messages by itself.
A hypothetical sensor message might define int32 reading = 1 and string unit = 2. Readers use the schema to interpret the encoded fields. When the schema evolves, existing field numbers must not be repurposed. Compatible additions can support gradual upgrades, but compatibility depends on the specific change and encoding.
A schema assigns stable field numbers; an encoder writes a binary message and a decoder reconstructs values. The numbered boxes are schematic, not literal encoded bytes. Removed field numbers must not be recycled.
Also called: GraphQL API, GraphQL schema, resolvers
GraphQL defines a query language, a type system and execution rules for APIs. A client selects fields from the service’s schema, and server-side functions resolve those fields. It is not a database and does not require a graph database; a separate transport carries operations and responses.
A hypothetical query { book(id: 7) { title author { name } } } requests only those fields. The result follows that selected shape, subject to errors and nullability rules. The schema constrains available operations, while application logic must still enforce authorization and control expensive work. Asking for fewer fields does not guarantee fewer underlying database queries.
The query selects title and author.name; isbn is omitted from the response. Resolvers can use different data sources. The selected response shape neither defines the underlying database nor guarantees one database query.
Also called: OAS, OpenAPI description, Swagger specification
OpenAPI is a standard format for describing HTTP APIs in a machine-readable document. It can specify paths, operations, parameters, request bodies, response schemas and security requirements. Documentation tools, client generators and validators can use that description; OpenAPI itself is not the protocol that carries an API call.
A hypothetical document can describe GET /books/{id} as accepting an integer identifier and returning a Book representation or a 404 response. The running server must still implement that contract. A valid description does not prove that the server obeys it, and the OpenAPI document’s specification version is distinct from the API’s product version.
An OpenAPI description can drive documentation, client generation, and contract checks. Actual calls still travel over HTTP to an implemented server; the format’s specification version is separate from the API’s product version.
A webhook is an integration pattern in which a system sends an HTTP request to a registered endpoint when an event occurs. It lets the receiver learn about changes without repeatedly polling for them. The event format, authentication and delivery rules belong to the provider’s contract.
For a hypothetical repository, a push event can trigger an HTTP notification to a build service. That service verifies the delivery, records it and schedules work. Failures, retries and manual redelivery can require duplicate handling; ordering and automatic retries vary by provider. A successful HTTP acknowledgment can mean the event was accepted without proving the build already finished.
A hypothetical receiver verifies and records a webhook before acknowledging acceptance. The build runs later. Possible redelivery rejoins duplicate handling; retry and ordering behavior depend on the provider’s contract.
Also called: API compatibility, API evolution, backward compatibility
API versioning gives clients a way to select or identify a contract as that contract evolves. A version might appear in a path, request field or service definition. Versioning policy should explain compatibility, migration and retirement; a new label alone does not preserve old clients’ expectations.
In a hypothetical books API, renaming title to displayName can break existing readers. Keeping the old field while adding another may permit a gradual migration, if the documented compatibility rules allow it. Some providers expose major versions such as /v1/; others evolve a compatible interface. This is separate from choosing HTTP/2 or HTTP/3.
This hypothetical policy first keeps both fields, then removes title under a changed contract. Even additive changes need compatibility rules. Selecting an API contract is separate from selecting HTTP/1.1, HTTP/2, or HTTP/3.
Secure channels
How software protects communication, checks peer identities, and selects the service on a connection.
Transport Layer Security protects communication against eavesdropping and undetected modification while authenticating peers according to its configuration. A handshake establishes cryptographic keys; protected records then carry application data. In a typical web connection, the client authenticates the server, while user login happens separately.
For example, HTTPS can carry an account request through a TLS connection so a network observer cannot simply read its contents. Protection ends where TLS terminates: a gateway that decrypts traffic can read it. TLS does not establish whether a website’s business claims are honest.
TLS protects application data between its endpoints. The endpoints can read plaintext; a network observer sees protected traffic and some connection metadata. User authorization remains separate.
A TLS handshake agrees on cryptographic parameters, establishes keys, and authenticates the peer or peers required by the chosen mode. In a full TLS 1.3 handshake using certificates, the client and server exchange key shares, the server proves its identity, and Finished messages bind the exchange together.
For example, a browser sends ClientHello and receives ServerHello, followed by encrypted server handshake messages. It validates the server’s credentials before completing its side. This is a simplified certificate-based flow: resumption, client authentication, and a retry request can change the messages, and early data has additional replay considerations.
Simplified full, certificate-based TLS 1.3 handshake. Server authentication messages and both Finished messages are encrypted after ServerHello. Client certificates, retry, resumption and 0-RTT are omitted.
Also called: digital certificate, X.509 certificate
A digital certificate binds a public key to a named subject under an issuer’s signature. In the X.509 format used by many TLS deployments, it also carries validity dates and constraints on how the key may be used. The public certificate can be shared; the corresponding private key must remain protected.
For example, a server presents a certificate for api.example.com. A client checks the name and other applicable requirements, including a valid path to a trusted issuer. Merely receiving a certificate is insufficient, and the certificate alone cannot prove the presenter possesses the private key.
The public certificate binds a name and public key under an issuer’s signature. The private key stays separate. Certificate validation and proof of private-key possession are both needed for the illustrated TLS authentication.
Also called: CA, certification authority, trust chain
A certificate authority issues and signs certificates under a stated policy. A relying application accepts a certificate only if its checks establish an appropriate path to a trust anchor it already trusts. A self-signed root does not become trustworthy merely by signing itself.
For example, a browser may validate a server certificate through an intermediate CA to a root in its trust store. Signatures establish links in that chain, while validity and constraints still matter. Public and private organizations can operate CAs; accepting an organization’s private CA is a separate trust decision.
Issuers sign certificates down the chain; the client validates a path toward a root already in its trust store. Validity, names and constraints still need checking. A root’s self-signature does not create trust.
Also called: mTLS, client certificate authentication
Mutual TLS authenticates the client as well as the server using certificates and proof of possession of their private keys. Each side applies its configured trust and identity checks. This is useful when services need an authenticated machine identity before accepting a request.
For example, an inventory service can require a calling warehouse service to present an accepted client certificate. The certificate identifies the peer; application policy still decides which inventory it may change. Certificates also need issuance, renewal, and revocation handling. Mutual TLS does not automatically grant every authenticated client unrestricted access.
Mutual TLS requires each peer to present credentials and prove private-key possession. Private keys remain local. After authenticating the client service, the server still applies its authorization policy.
Secure Shell is a protocol family for secure remote login and other services over an untrusted network. Its transport layer authenticates the server and protects traffic, a user-authentication layer establishes the client’s identity, and a connection layer carries multiple logical channels.
For example, a developer can run a command on a server while a separate channel forwards a local port. Checking the server’s host key matters: encrypting traffic to an impostor still connects to an impostor. A saved host key and an authorized user key serve different sides of the authentication process.
SSH protects a transport that can carry separate command and port-forwarding channels. The client checks the server’s host key; the server separately authenticates the client. This is SSH, not a TLS tunnel.
Also called: Application-Layer Protocol Negotiation
Application-Layer Protocol Negotiation is a TLS extension that lets peers agree which application protocol a connection will carry. The client offers protocol identifiers, and the server selects a supported choice. This lets services share a port without guessing the application protocol from later payload bytes.
For example, a client may offer h2 and http/1.1, and the server select h2 for HTTP/2. That selects the application protocol, not the TLS version or the hostname. The selection is part of the handshake; the exact response message depends on the TLS version.
Illustrative ALPN selection: the server chooses h2 from protocols both sides support. This selects HTTP/2, not the TLS version. The diagram does not assign the response to a TLS-version-specific handshake message.
Server Name Indication is a TLS extension through which a client supplies the hostname it intends to reach. A server hosting several domains at one network address can use that name to select a certificate and virtual service before application requests arrive.
For example, a client connecting to a shared address sends shop.example.com as the server name rather than its numeric IP address. SNI helps choose the destination configuration; the client must still validate the certificate for the intended host. The base extension itself does not encrypt the hostname or establish its authenticity.
SNI supplies the hostname shop.example.com to choose a virtual service and certificate on a shared server. Selection is followed by certificate validation. The base SNI extension does not itself encrypt the hostname.
Identity and access
Distinguishing identity checks, permissions, delegated access, and the tokens exchanged between services.
Authentication checks a claim about an identity or the origin of information using evidence the system accepts. A username says which identity is claimed; a password, cryptographic challenge response, or another credential provides evidence. Humans, services, and devices can all be authenticated.
For example, a server may verify that a client can sign a fresh challenge with an expected private key. This establishes a particular identity under the system’s assumptions. It does not determine whether that identity may delete a project; that separate decision belongs to authorization.
Illustrative challenge–response authentication: Ana proves possession of the expected private key by signing a fresh challenge. Accepting that proof establishes an identity under the system’s assumptions; permission is a separate decision.
Authorization determines what an entity is allowed to do with a resource. A decision can depend on identity, assigned roles, requested action, resource ownership, and other context. Permissions should be enforced where the resource is accessed, not merely by hiding controls in a user interface.
For example, the same authenticated developer may read a repository but be denied permission to delete it. A service must evaluate the requested operation against its policy. Some resources also allow anonymous access, so authorization decisions need not always follow a named-user login.
Hypothetical repository policy: the same authenticated developer can read but cannot delete. Authorization evaluates the requested action on the resource; hiding a delete button does not enforce this policy.
OAuth 2.0 is a framework for obtaining limited access to protected resources. A client receives an access token from an authorization server and presents it to a resource server. In delegated access, a resource owner can authorize that client without giving it their account password.
For example, a calendar app might receive permission to read events without permission to delete them. Scopes and resource policy determine the access granted; the client does not automatically receive all account privileges. OAuth alone is not a standard login identity assertion: OpenID Connect supplies that identity layer.
Illustrative delegated calendar access: the owner grants read access, the authorization server issues a limited token, and the client presents it to the calendar API. Resource policy permits reading but denies deletion; the token’s format is unspecified.
Also called: authorization code grant, OAuth code flow
The authorization code flow obtains an access token in two stages. After the authorization interaction, the browser returns a short-lived code to the client. The client exchanges that code at the token endpoint, supplying the required checks and credentials, rather than treating the code itself as an API token.
For example, a scheduling app receives a code after calendar access is approved, then exchanges it using PKCE. Public clients must use PKCE under OAuth’s security best practice; confidential clients are also advised to use it. Redirect validation and protection against forged or injected responses remain essential.
Simplified authorization code flow with PKCE. The browser returns a code; the app then sends code plus verifier to the token endpoint. The access token comes from that separate exchange, after required validation and client authentication where applicable.
Proof Key for Code Exchange binds an OAuth authorization request to the later code exchange. The client generates a random verifier, sends a derived challenge with the first request, and supplies the verifier when redeeming the code. The server checks that the two correspond.
For example, with the S256 method the challenge is a base64url-encoded SHA-256 hash of the verifier. Someone intercepting only the authorization code cannot redeem it without that verifier. PKCE is not a replacement for HTTPS, redirect validation, or client authentication where client authentication is required.
With the S256 PKCE method, the client retains a random verifier and sends only its derived challenge with the authorization request. The token exchange later supplies code and verifier; the server recomputes the challenge and compares them. Hashing is not encryption.
OpenID Connect adds an identity layer to OAuth 2.0. It lets a client learn about an end user authenticated by an OpenID Provider through an ID token and defined validation rules. This supports interoperable sign-in while OAuth access tokens remain concerned with access to resources.
For example, an application can sign a person in using an employer’s identity provider. It checks the ID token’s issuer, audience, expiry, and applicable cryptographic and nonce requirements before relying on it. An ID token is intended for that client; it should not simply be substituted for an API access token.
OpenID Connect adds an ID token for the client to validate before accepting a sign-in identity. Access tokens serve resource access. The diagram separates these purposes; the ID token is not a substitute for an API access token.
A JSON Web Token is a compact representation of claims, such as a subject, issuer, audience, or expiry. JWTs can be protected with a signature or message authentication code, encrypted, or nested. A common signed compact JWT has three base64url-encoded parts: header, payload, and signature.
For example, a service receiving a signed token must validate the accepted cryptographic protection and the claims required by its token profile. Decoding the payload does not validate it. Encoding also does not make it secret: readable signed claims require encryption if confidentiality is needed.
A signed compact JWT has header, payload and signature segments. Decoding reveals illustrative claims; validation separately checks cryptographic protection and required claims. These three segments do not describe encrypted JWTs, and signed payloads are not secret.
Also called: Security Assertion Markup Language, SAML 2.0, single sign-on
Security Assertion Markup Language defines XML assertions and protocols for communicating authentication and other security information. In browser single sign-on, an identity provider authenticates a user and supplies an assertion that a service provider can validate under an established trust relationship.
For example, an employee opening a company tool may be redirected to the corporate identity provider, then return with a SAML response. The tool checks the assertion’s integrity, issuer, intended audience, timing, and applicable request bindings. A signed assertion is not automatically acceptable to every service or indefinitely reusable.
Simplified service-provider-initiated browser SSO. The browser visits the identity provider and carries a SAML response back to the application. The service provider validates the assertion and applicable request bindings before accepting it.
Identity lifecycle
How sessions and credentials are checked, renewed, rotated and withdrawn throughout their lifetime.
Also called: web session, login session, session identifier
A web session connects separate requests to a continuing application context, such as a signed-in account. In a common design, the browser holds an unpredictable session identifier in a cookie while the server stores the associated state. The cookie is the delivery mechanism; the session also includes the server’s rules for creation, expiry and invalidation.
For example, a museum site maps a session identifier to a visitor’s account and pending bookings. After login it replaces the identifier to reduce session-fixation risk. Logout invalidates the server-side session as well as clearing the browser cookie. Merely deleting a cookie does not prevent a copied identifier from being accepted by an unchanged server.
The cookie carries fictitious identifier S7; the server holds the account and booking state. Logout clears the cookie and invalidates the server-side association, so a copied old S7 is rejected.
Also called: CSRF, XSRF, cross-site request forgery
Cross-site request forgery, or CSRF, exploits the browser’s ability to attach eligible credentials automatically. An attacker induces a request to a site where the victim is signed in; a vulnerable server mistakes the attached session cookie for evidence that the user intended the action. Cookie rules affect which cross-site requests carry credentials.
For example, a malicious page submits an address-change form to a vulnerable shop. The browser may include the shop’s session cookie even though the shop did not create that form. A validated CSRF token can distinguish the legitimate workflow. SameSite cookies and origin checks provide additional defenses; blocking cross-origin response reading with CORS does not, by itself, prevent all such requests.
An attacker induces the form request without reading the session cookie. The browser adds the shop cookie only when its rules allow it. This shop separately checks the expected CSRF token and rejects the missing-token request.
Also called: OAuth refresh token, refresh token rotation
A refresh token lets an OAuth client request fresh access tokens from the authorization server without repeating the full authorization interaction each time. It is not sent to the resource API. Issuing one is a policy choice, and its ability to prolong access makes its protection especially important.
For example, a calendar client exchanges refresh token R1 for a new access token. With rotation, the server also returns R2 and invalidates R1, retaining their relationship so reuse can reveal compromise. Current OAuth security guidance requires public-client deployments that issue refresh tokens to detect replay using rotation or sender-constrained tokens. Refreshing must remain within the authorization originally granted.
In this refresh-token rotation example, R1 goes only to the authorization server. The client stores replacement R2 and uses the new access token A2 at the calendar API. R1 is invalidated.
Token introspection lets an authorized service ask an OAuth authorization server about a token’s current status and associated metadata. The response includes active and may include scope, audience and expiry. It can be used with different token formats; an opaque token is a common use case, not a requirement.
For example, a printing API submits a token to its trusted introspection endpoint and receives active: true with a read-only scope. That does not permit starting a print job: the API still checks the requested operation. Caching introspection results reduces traffic but can delay recognition of revocation, creating a deliberate freshness tradeoff.
The authorized API learns that the token is active with jobs.read scope, then denies a print operation. An optional cached answer can become stale before its next refresh.
Token revocation ends a token’s acceptance before its ordinary expiry. OAuth defines an endpoint where a client can ask the authorization server to invalidate a refresh or access token. Which related tokens also become invalid depends on the token type and server policy. Deleting a local copy alone does not revoke another copy.
For example, disconnecting a calendar integration can revoke its refresh token so it cannot obtain more access tokens. Already-issued access tokens require enforcement too. An API that only checks a JWT’s signature and expiry offline does not automatically learn about revocation; it needs an additional state-checking or notification mechanism, or must rely on expiry to bound continued acceptance.
Revoking R stops future refreshes. Whether related access token A is also revoked depends on policy. A fresh state check can enforce A’s revocation; signature and expiry checks alone do not learn about the later event.
A JSON Web Key Set, or JWKS, is a JSON object containing a keys array of cryptographic keys in JWK format. Identity systems commonly publish public verification keys this way. A token’s kid can help select a matching key, but the identifier is a hint, not proof that the key or issuer is trustworthy.
For example, a trusted issuer publishes old and new public signing keys during a rotation. An API selects the appropriate key and then verifies the token under its configured validation rules. It obtains keys from the trusted issuer’s established location, not an arbitrary address supplied by a token. Public verification endpoints must not expose private signing material.
A trusted issuer publishes candidate public verification keys while keeping private material private. The token’s kid selects a candidate; verification and claims checks still follow. Never trust an arbitrary key location supplied by a token.
JWT claims validation asks whether a cryptographically valid token is acceptable for this application and request. A verifier uses allowed algorithms and trusted keys, then checks the required issuer, audience, time bounds and token purpose. Merely decoding JSON proves nothing. Required claims and rules come from the token’s application profile.
For example, a billing API rejects a correctly signed token whose aud identifies the photo API. It also rejects an expired token and does not substitute an OpenID Connect ID token for its expected access token. Claims such as exp and nbf have defined time meanings, but not every JWT profile requires the same claim set.
The signature and issuer pass, but this billing API rejects the photo-api audience. Time bounds and token purpose are additional gates for tokens that pass earlier checks; exact claim requirements depend on the application profile.
WebAuthn is a browser API for registering and using public-key credentials scoped to a relying party, such as a website. The site stores a public key; an authenticator proves control of the corresponding private key. WebAuthn supports passkey sign-in, while CTAP covers communication with compatible external authenticators. A passkey is not an HTTPS certificate.
For example, a library website sends a fresh challenge during sign-in. After user interaction, the authenticator produces a signed assertion. The website verifies the challenge, origin, relying-party identity and signature against the registered credential, plus its required user-verification policy. A local fingerprint or PIN can unlock the operation without becoming a reusable password sent to the site.
The authenticator returns a signed assertion for a fresh challenge and intended relying party. The website verifies it using the registered public key and its policy; the user’s local PIN or biometric is not sent as a password.
Messaging protocols
Sending events through brokers, choosing delivery guarantees, and handling messages that cannot be processed.
Publish–subscribe is a communication pattern in which publishers send messages without naming each recipient. Subscribers express interest in a topic, channel, or other selection rule, and the messaging system distributes matching messages. It is a pattern supported by several protocols, not a single wire format.
For example, an order-created event can reach a notification service and an analytics service independently. That differs from competing workers sharing one queue, where a delivery is assigned to one worker. Whether disconnected subscribers later receive events depends on subscriptions, retention, and the chosen system’s guarantees.
Hypothetical order-created event reaches two separate subscriptions, notifications and analytics. Each receives a copy in this example. This is different from workers competing within one consumer group; offline retention depends on the system.
A message broker is an intermediary that accepts messages and delivers them according to routing and storage rules. It can separate producers from consumers in time and location, but its supported protocols, persistence settings, and failure behavior determine what guarantees applications actually receive.
For example, a job producer may send work to a broker while workers consume queued jobs later. In RabbitMQ, an exchange routes messages into queues according to bindings; other systems use different models. The broker is running software, while AMQP or MQTT specifies communication rules used with it.
RabbitMQ example: an exchange routes producer messages into a queue. Two jobs wait while a worker processes an earlier job. The broker is software; protocols define exchanges with it, and durability depends on configuration.
MQTT is a compact client/server publish–subscribe messaging protocol used in many device and telemetry systems. Clients publish to topic names and subscribe with topic filters. A server, commonly called a broker, forwards matching application messages and manages the protocol’s session behavior.
For example, a sensor can publish a reading to building/room1/temperature while a dashboard subscribes to building/+/temperature. MQTT defines three quality-of-service levels with different delivery behavior. Those guarantees concern protocol delivery between a sender and receiver; they do not automatically make an external action, such as charging a card, happen exactly once.
Illustrative MQTT publication to building/room1/temperature matches the subscription filter building/+/temperature. The wildcard is in the filter, not the published topic. Publisher-to-broker and broker-to-subscriber deliveries are separate hops with their own QoS behavior.
Also called: Advanced Message Queuing Protocol, AMQP 1.0
Advanced Message Queuing Protocol specifies interoperable message exchange. AMQP 1.0 defines binary encoding, message transfer, message formats, and related capabilities. It can connect processes directly or through messaging infrastructure; a particular broker’s queue names and routing conventions are not the whole protocol.
For example, an AMQP 1.0 sender can transfer a business message over a link and receive a delivery outcome from its peer. The version matters: AMQP 1.0 and AMQP 0-9-1 are different wire protocols. A library supporting one cannot be assumed to communicate with an endpoint supporting only the other.
Simplified AMQP 1.0 containment and exchange: a link within a session carries a message, and the peer returns an illustrative accepted outcome. This does not prove an external business effect. AMQP 0-9-1 is wire-incompatible.
Kafka clients communicate with brokers using a versioned binary protocol over TCP. Requests cover operations such as discovering cluster metadata, producing records, and fetching records. Clients use metadata to find the brokers responsible for the topic partitions they need.
For example, a consumer requests records from a partition starting at an offset, while a producer sends records to its partition leader. Ordering is defined within a partition, not across an entire multi-partition topic. The wire protocol also carries coordination operations; Kafka is more than a generic queue with one global sequence.
Illustrative Kafka exchange: metadata identifies a partition leader; the client produces records and fetches from a specified offset. Offsets 0, 1 and 2 belong independently to each partition. The basic Fetch path is requested by the client, not broker push.
Also called: delivery guarantees, at most once, at least once, exactly once
Delivery semantics describe the outcomes a messaging system promises under stated failures and assumptions. At-most-once delivery may lose work but avoids redelivery. At-least-once delivery retries uncertain work and can produce duplicates. Exactly-once processing requires a defined boundary within which repeated attempts produce one committed result.
For example, a consumer can update a database and crash before acknowledging its message. Redelivery may repeat the database change unless the application deduplicates or coordinates the two steps. Kafka transactions can coordinate supported Kafka records and offsets; effects in another system require cooperation from that system.
Schematic outcomes for one intended message: at-most-once can miss completion; at-least-once can repeat processing; coordinated repeated attempts can produce one committed result within an explicit boundary. External effects lie outside that boundary unless coordinated too.
A consumer acknowledgment tells a messaging system that a particular delivery has reached the application’s chosen completion point. With manual acknowledgments, the consumer decides when to send that signal. If a connection fails before acknowledgment, the system may make the message available for redelivery.
For example, a worker can acknowledge a job after saving its result. A crash after saving but before acknowledging can still cause duplicate work, so the saved effect needs suitable protection. A broker confirming a publisher’s submission is a different event: it does not mean a consumer has finished processing.
A worker saves its result before sending the consumer acknowledgment. A crash after commit but before ACK can lead to redelivery and a repeated effect. The dashed arrows show alternative failure handling; publisher confirmation does not establish consumer completion.
Also called: DLQ, dead lettering, dead-letter exchange
A dead-letter queue holds messages redirected out of their normal processing path because they cannot continue under configured rules. Reasons can include rejection, expiry, or a delivery limit. The precise triggers and delivery guarantees depend on the messaging system and its configuration.
For example, a worker repeatedly encounters an unsupported payload version and routes the message for investigation. In RabbitMQ, a dead-letter exchange routes such messages onward to a bound queue; the exchange and queue are distinct. Keeping failed messages helps diagnosis, but correction, replay policy, and duplicate-effect protection still need explicit handling.
RabbitMQ example: a worker rejects an unsupported payload without requeueing; the normal queue dead-letters it through an exchange to an investigation queue. The dashed path represents an explicit corrected replay, not automatic recovery or a guarantee of lossless transfer.
Service messaging
Service descriptions, lightweight messaging protocols and the coordination patterns around message delivery.
SOAP is an XML-based messaging framework with rules for message structure, processing and bindings to underlying protocols. In SOAP 1.2, an envelope contains a body and may contain a header for additional information. A defined Fault structure reports processing problems. Sending arbitrary XML over HTTP does not, by itself, make a message SOAP.
For example, a supplier sends a stock inquiry in a SOAP body over the SOAP HTTP binding, and receives a stock result or a fault. HTTP is a common binding, not SOAP’s entire definition. SOAP 1.1 and 1.2 have different namespaces and processing details, so clients must use the version and binding their service contract specifies.
SOAP 1.2 structures a message with an optional Header and required Body. This example uses an HTTP binding; a supplier returns a result Body or a Fault inside the Body. The envelope is distinct from its transport.
Also called: Web Services Description Language, WSDL 2.0
WSDL describes a web service contract: operations, exchanged data, protocol bindings and endpoint addresses. It is a description language, not the messages’ transport. In WSDL 2.0, an interface defines abstract operations, a binding supplies concrete messaging details, and a service exposes endpoints. Tools can use the description to help construct clients.
For example, a warehouse contract describes a stock-check operation, its request and response shapes, a SOAP binding and an endpoint address. Reading the contract does not execute the operation. WSDL 1.1 uses different structures and names, including portType and port; its documents cannot simply be interpreted as WSDL 2.0 documents.
The WSDL 2.0 description separates interface, binding, and service endpoint. A tool reads that contract to generate client code; the runtime client later exchanges actual messages with the service.
NATS is a messaging system with a client-server protocol that routes messages by named subjects. Core NATS supports publish-subscribe, request-reply and queue groups with at-most-once delivery: an offline subscriber cannot later retrieve a missed message from Core NATS. JetStream adds stored streams, replay and consumer delivery features.
For example, a greenhouse publishes live readings on greenhouse.east.temperature. A connected dashboard can receive them through Core NATS. If an auditor must retrieve readings after a network outage, the deployment can use an appropriately configured JetStream stream and consumer. Those persistence and acknowledgment semantics belong to JetStream, not to every NATS publication, and depend on its configuration.
Two configurations for the same publisher: Core NATS is ephemeral and delivers at-most-once to live subscribers; an appropriately configured JetStream stream adds storage and later replay.
Also called: Simple Text Oriented Messaging Protocol, STOMP 1.2
STOMP is a simple protocol for exchanging messages through a server. STOMP 1.2 frames have a command, headers and an optional body, which may contain binary data. Clients use commands such as SEND and SUBSCRIBE; servers deliver MESSAGE frames. Destination strings are intentionally opaque, so their queue or topic behavior depends on the server.
For example, a worker subscribes to a broker’s /queue/labels destination using ack:client-individual. After handling a MESSAGE, it sends the corresponding ACK. That path is a broker convention, not a universal STOMP naming rule. Choosing auto acknowledgment changes the guarantee: the server assumes delivery when it sends the message, rather than waiting for an explicit client acknowledgment.
STOMP 1.2 client-individual mode: after processing MESSAGE ack:m7, the worker sends ACK id:m7. These are frame excerpts; /queue/labels is a broker-specific destination convention.
Also called: Constrained Application Protocol, CoAP over UDP
CoAP is a compact application protocol designed for constrained devices and networks. It exposes resources through methods such as GET and PUT, with response codes and options. The base RFC 7252 protocol uses UDP and includes its own message acknowledgment machinery. RFC 8323 separately defines operation over TCP, TLS and WebSockets.
For example, a controller sends a confirmable GET for a greenhouse’s humidity resource over UDP. If the reading is ready, the device can return 2.05 Content inside the acknowledgment. Otherwise it can acknowledge receipt and send the result separately. An acknowledgment therefore need not mean the application result is already available. CoAP resembles HTTP’s resource model but has its own wire format.
In the UDP form of CoAP, the sensor may return a piggybacked result in its ACK. In the alternate flow an empty ACK confirms receipt, while the result arrives later. Additional response acknowledgment details are omitted.
Also called: message schema registry, Confluent Schema Registry
A schema registry stores and serves definitions of message structures, often with versions and compatibility checks. It helps producers and consumers agree on how to encode and interpret data. It is a service and coordination pattern, not one universal wire protocol. A registry manages schemas; the messaging system carries the business records.
For example, a Confluent Schema Registry subject tracks versions of a shipment event’s Avro schema. A producer proposes a new version, and the registry checks it against the configured compatibility policy before accepting it. Consumers use the appropriate schema to decode records. Passing a structural compatibility check does not prove that changed fields retain the same business meaning.
This example checks a proposed schema under a backward-compatibility policy. The registry serves schema metadata; the broker carries shipment records. Structural compatibility does not prove that business meaning is unchanged.
Also called: outbox pattern, transactional messaging outbox
The transactional outbox pattern coordinates a database change with a message that must eventually be published. The application writes both its business data and an outbox record in one database transaction. A separate relay later publishes the committed outbox record. This avoids the gap where a database commit succeeds but the corresponding direct message send fails.
For example, confirming a ticket reservation also inserts a “reservation confirmed” event in the same transaction. A relay publishes that event after commit and retries after outages. If it publishes and crashes before recording progress, it may publish again. Consumers therefore need duplicate handling; the pattern alone does not guarantee exactly-once effects across the database, broker and downstream services.
The reservation and outbox event commit together in one local database transaction. A later relay publish can repeat E7 after a crash, so consumers need duplicate handling. The database transaction does not include the later publish.
Also called: Kafka consumer group, partition consumer group
A consumer group coordinates workers that share message consumption, but the precise rules depend on the messaging system. In Kafka’s partition-based consumer groups, each assigned partition belongs to one member at a time. Separate groups can independently read the same topic. This differs from a generic queue that distributes individual messages among available workers.
For example, a Kafka topic has four partitions and an indexing group has two consumers. Each consumer can own two partitions; a separate analytics group reads the topic independently. Membership changes can trigger reassignment, and committed offsets determine where processing resumes. Group membership alone does not make side effects exactly once. Other systems’ queue groups and Kafka’s share groups use different coordination models.
A partition belongs to one member within each Kafka partition-based group. The indexing group shares four partitions between A and B; the separate analytics group assigns all four to C. Their illustrative P0 offsets differ.
Real-time communication
Streaming events, interactive connections and the protocols that establish and carry live media.
WebSocket provides a persistent channel for text or binary messages in both directions between a client and a server. After an opening handshake, either peer can send messages without waiting for a new request. Its framing preserves message boundaries, unlike a raw TCP byte stream.
A collaborative editor can send a keystroke update and receive another person’s edit on the same connection. The original HTTP/1.1 handshake uses an Upgrade request and a 101 response; other HTTP versions have their own bootstrapping rules. Secure WebSockets use TLS. Reconnection, authorization and application acknowledgments still need an application design.
Server-sent events carry a sequence of text events from a server to a client over a long-lived HTTP response. The browser’s EventSource API parses the UTF-8 event stream and normally reconnects after a disconnection. This channel carries events toward the client; client commands can use separate HTTP requests.
A build dashboard might receive queued, running and finished events without polling. An event can include an ID that EventSource sends back as Last-Event-ID when reconnecting. The server must implement any replay behavior; the ID alone does not ensure that missed events are retained or delivered exactly once.
Also called: Web Real-Time Communication, RTCPeerConnection
WebRTC is a family of browser APIs and protocols for real-time audio, video and application data. It combines session description, connectivity checks, secure media transport and data channels. It is more than one wire protocol, and a peer connection may reach another browser or a server.
In a video-call app, an application-chosen signaling service exchanges setup information. ICE then tests possible paths; media can travel directly or through a TURN relay when necessary. WebRTC does not prescribe the application’s signaling protocol, and a peer-to-peer interface does not guarantee that the network path avoids servers.
SDP is a text format describing a multimedia session: its media types, codecs, timing and transport-related parameters. Despite its name, it does not deliver the media or by itself define the negotiation exchange. Other protocols and procedures carry and interpret the description.
A calling application might exchange an offer describing an audio stream and an answer selecting compatible settings. SDP supplies the structured descriptions; the offer/answer procedure and signaling channel supply the surrounding rules. Reading a codec name in an SDP document therefore tells you about proposed or agreed configuration, not that audio packets have already arrived.
ICE finds a usable connection path by collecting candidate addresses, exchanging them through signaling, and testing candidate pairs. Candidates can represent local interfaces, addresses learned through STUN, or relays allocated with TURN. A successful pair can be nominated for the communication.
Two laptops behind different routers may first try a direct path and use a relay if that path cannot work. ICE checks reachability rather than assuming that a published address is reachable. Its checks are distinct from the application’s signaling channel, and the selected route depends on connectivity, priorities and policy rather than a promise of the shortest physical path.
STUN supplies building blocks for NAT traversal. A binding request can reveal the source IP address and port that a server observes, which may differ from a device’s local address. STUN messages also support connectivity checks and maintaining mappings in a larger protocol design.
A laptop might send from a private address while a STUN server sees a router’s public address and translated port. That observation can help ICE build a candidate. STUN does not relay the application’s audio or video, and learning a mapped address does not guarantee that another peer can send traffic through the NAT to it.
TURN lets a client allocate a relay address on a server and exchange traffic with peers through it. It helps when network restrictions prevent a usable direct path. The client authenticates to obtain an allocation, maintains it with refreshes, and establishes permissions for the relevant peers.
A video-call client behind a restrictive firewall can send media through its TURN server, which forwards packets toward the other participant. This uses relay bandwidth and adds another network hop. The relay supplies connectivity; media confidentiality depends on the protocols protecting those packets, rather than on the word relay itself.
Also called: Real-time Transport Protocol, RTP Control Protocol
RTP carries real-time media with information such as a sequence number, timestamp and payload type. These fields help a receiver order packets and relate samples to a media clock. Its companion RTCP carries control information, including reports used to monitor delivery and synchronize streams.
In a voice stream, received sequence numbers 410, 411 and 413 reveal a possible missing packet. A receiver may conceal the gap instead of waiting indefinitely. RTP by itself does not reserve bandwidth, guarantee delivery or encrypt content; profiles and companion protocols supply additional behavior. WebRTC uses protected media transport rather than bare RTP alone.
Also called: Session Initiation Protocol, SIP signaling
Session Initiation Protocol establishes, changes, and ends communication sessions such as internet phone calls. Its requests and responses handle signaling: locating a participant, inviting them, and tracking a dialog. Session descriptions carried in SIP messages can describe media choices, while separate protocols carry the actual audio or video.
For example, a phone sends INVITE, receives an acceptance response, and sends ACK before the participants converse. A later BYE ends the dialog. Proxies may route signaling between domains, but that route need not be the media path. Protecting SIP signaling also does not automatically encrypt the voice packets.
Simplified SIP signaling through a proxy: INVITE, acceptance and ACK arrange the call; a later BYE ends it. The direct RTP media path is illustrative and can differ in deployed systems. Signaling protection does not automatically protect media; other responses are omitted.
Also called: Real-Time Streaming Protocol, RTSP 2.0
Real-Time Streaming Protocol controls a media delivery session. A client can establish transport parameters, start playback, pause where the resource supports it, and release session resources. Media commonly uses RTP, so the control conversation and the media packets serve different purposes even when a transport arrangement shares a connection.
For example, a player can SETUP a recorded stream, issue PLAY, pause it, and finish with TEARDOWN. Those commands do not define the video codec or make lost media packets reappear. RFC 7826 specifies RTSP 2.0; its details should not be assumed interchangeable with an older RTSP 1.0 implementation.
Simplified RTSP 2.0 recorded-stream sequence: SETUP reaches Ready, PLAY starts playback, supported PAUSE returns to Ready, and TEARDOWN releases resources. Commands and media are separate logical roles; responses and transport details are omitted.
Also called: Secure Real-time Transport Protocol, SRTCP, secure RTP
Secure Real-time Transport Protocol protects RTP media packets with cryptographic services such as confidentiality, integrity, and replay checking, according to the selected profile. A companion mechanism, SRTCP, protects RTCP control traffic. These protections operate on packetized media; they do not turn delivery into a reliable byte stream or prevent network loss.
For example, participants in a WebRTC call can use a DTLS handshake to establish keying material, then use SRTP for audio and video. The media packets are protected by SRTP rather than carried as ordinary TLS application data. Key establishment and media protection are distinct jobs, and some packet metadata remains visible.
In DTLS-SRTP, the handshake establishes keys, then SRTP separately protects media packets. The conceptual packet keeps visible header information distinct from protected payload and integrity services. SRTCP protects control traffic; protection does not recover lost packets.
Also called: Datagram Transport Layer Security, DTLS 1.3
Datagram Transport Layer Security protects communication over datagram transports such as UDP. It adapts TLS-style authentication and encryption to a setting where packets can be lost, duplicated, or reordered. DTLS 1.3, defined in RFC 9147, builds on TLS 1.3 and includes machinery to complete a handshake despite packet loss.
For example, a game can protect position updates while allowing newer updates to arrive after an older datagram disappears. DTLS handshake retransmission does not make application messages reliably ordered; an application needing that behavior adds it elsewhere. DTLS versions have different details, so a reference to DTLS in another protocol does not necessarily mean version 1.3.
Conceptual DTLS 1.3 behavior: handshake machinery recovers a lost handshake flight, while protected application datagrams can still be lost. A later update can arrive despite an earlier loss. This is not a claim that all DTLS uses or WebRTC deployments use version 1.3.
Also called: Stream Control Transmission Protocol, SCTP association, multistreaming
Stream Control Transmission Protocol carries messages across an association between endpoints. Unlike a byte stream, it preserves message boundaries and can provide several independently ordered streams, as well as unordered delivery. Its base service includes retransmission and congestion control; multihoming can provide alternate network paths in deployments that support it.
For example, one application can send commands on one stream and status messages on another without imposing one shared delivery order. The streams still share transport resources, so they are not independent bandwidth guarantees. WebRTC data channels use SCTP in a particular encapsulated mode; they do not expose every capability of native SCTP.
Illustrative ordered SCTP streams: A2 waits for delayed A1, while B1 and B2 can be delivered in their own stream order. Messages retain boundaries. Both streams share one association and transport resources; the picture does not promise independent bandwidth.
Also called: RTCDataChannel, data channel, SCTP over DTLS
A WebRTC data channel carries application messages between peers alongside, or without, audio and video. Its protocol stack uses SCTP over DTLS over an ICE-selected transport path. Channels can use ordered or unordered delivery and reliable or partially reliable transport, allowing applications to choose how long outdated messages remain worth sending.
For example, a game can send chat reliably while sending frequently refreshed position updates with limited retransmission. Those choices change delivery behavior without removing encryption. Data channels preserve message boundaries and have implementation or negotiated size limits. This WebRTC use of SCTP does not support SCTP multihoming; ICE handles path selection separately.
Illustrative WebRTC channels choose ordered reliable chat and unordered position updates with limited retransmission. Both feed SCTP over DTLS over the ICE-selected path. SRTP media is a parallel mechanism, not a layer in this stack; SCTP multihoming is absent in this mode.
A jitter buffer temporarily holds incoming media packets so playback can proceed at a steadier rhythm despite varying network delay. It is a receiver-side buffering mechanism, rather than a wire protocol. Packets arriving early wait; packets arriving after their playback deadline may be discarded because playing them would disrupt the timeline.
For example, a voice call can hold a small amount of audio to absorb uneven packet arrivals. Increasing that waiting period can accommodate more delay variation, but also makes the conversation feel slower. Adaptive buffers adjust the delay as conditions change; buffering cannot reconstruct a packet that never arrives or eliminate every audible gap.
Schematic example with a shared left-to-right time scale: A, B and C arrive before their evenly spaced playout slots, while D misses its original deadline. Delaying all playout slots by the same extra amount can admit D, at the cost of more latency. A buffer does not recreate missing content.
Also called: WebTransport API, WebTransport over HTTP/3
WebTransport gives web applications access to streams and datagrams for communication with a server. The browser API and the protocols used on the wire are separate specifications. The HTTP/3 binding uses QUIC to provide reliable streams and datagrams that do not guarantee delivery, within an established WebTransport session.
For example, a browser game can send reliable inventory changes on a stream and disposable position updates as datagrams. As inspected in November 2026, the W3C API was a July 2026 Candidate Recommendation Snapshot, while the HTTP/3 binding was Internet-Draft revision 17. Those statuses describe evolving specifications, not a final RFC or universal browser support.
WebTransport’s browser API exposes reliable streams and unreliable datagrams through a separate HTTP/3 wire binding over QUIC. Shown statuses are the inspected July 2026 W3C Candidate Recommendation Snapshot and November 2026 Internet-Draft revision 17, not final RFC or universal support claims.
Email and file transfer
How messages reach a mailbox, how clients read them, and how software transfers or shares files.
Also called: Simple Mail Transfer Protocol, mail relay
Simple Mail Transfer Protocol moves email between mail systems. A sender supplies an envelope identifying the return address and recipients, then transfers the message itself. Commands and numeric replies coordinate acceptance or failure; a successful handoff means the receiving server has accepted responsibility for the message.
For example, a company’s mail server can relay a message to the recipient’s mail provider using MAIL, RCPT, and DATA commands. That transaction does not prove the person has read the message. Submitting a newly composed email and reading an inbox are separate roles, covered by submission and mailbox-access protocols.
SMTP sends envelope addresses separately from the message’s headers and body. The recipient server’s acceptance transfers handling responsibility; it does not prove immediate final delivery or that a person has read the email. Replies before final acceptance are omitted.
Also called: message submission, SMTP submission, MSA
Email submission is the handoff of a newly composed message from an application to a service that will send it onward. It uses SMTP with submission-specific requirements, including sender authorization and message checks. The submission service and the servers relaying mail between organizations perform different roles, even when one machine hosts both.
For example, a mail app authenticates to its provider’s submission service before sending a newsletter. The provider can then relay the accepted message toward recipients. RFC 6409 reserves port 587 for submission; the port identifies a service convention, while authentication and transport protection require their own mechanisms.
The mail app submits a newly composed message to a service that checks authorization and message requirements. Servers then relay the mail onward. Port 587 is a submission service convention; it does not itself authenticate or encrypt the exchange.
Also called: Internet Message Access Protocol, IMAP4rev2
Internet Message Access Protocol lets a client work with email stored on a server. It supports mailboxes, message flags such as read status, searching, and fetching selected message parts. This server-based model helps multiple devices maintain a consistent view while also allowing local caches for offline use.
For example, a phone can fetch message headers first and download a large attachment only when opened. Marking the message as read changes a server flag that another client can observe. IMAP manages mailbox access; sending a new email uses a separate submission service. IMAP4rev2 is specified in RFC 9051.
IMAP exposes the server’s message headers, flags and attachment parts separately. The phone can fetch headers first and an attachment later. A laptop can update the shared seen flag; other clients observe it when they synchronize. Sending mail is a different service.
Post Office Protocol Version 3 provides a small command set for retrieving messages from a server maildrop. A client authenticates, lists or retrieves messages, and can mark messages for deletion. Its basic model is simpler than IMAP’s server mailbox and flag management; downloading does not inherently mean deleting.
For example, a desktop client can retrieve a message with RETR and keep a local copy while leaving the server copy intact. If it also issues DELE, deletion is deferred until the session enters the update stage after QUIT. An interrupted connection before that stage must not remove the marked messages.
Illustrative POP3 deletion path: RETR creates a local copy while the server copy remains. Optional DELE only marks the message. QUIT from the transaction state enters update and attempts removal; retrieval alone does not delete it.
Also called: Multipurpose Internet Mail Extensions, MIME message format
Multipurpose Internet Mail Extensions describe how a message body can contain different media types, character sets, and encoded data. MIME is a family of message-format rules, rather than a delivery protocol. Content-Type identifies what a part contains; Content-Transfer-Encoding describes how its bytes were represented for transport.
For example, an email can contain a text part and a photo attachment inside a multipart body. Each part carries its own descriptive headers, and the photo may use base64 encoding. The receiving application decodes those bytes before displaying the image. Base64 changes representation; it does not encrypt the attachment or authenticate its sender.
A MIME multipart body separates parts with boundaries and gives each part descriptive headers. The illustrated image part uses base64 transfer encoding; decoding recovers image bytes. MIME is a message format, and base64 supplies no confidentiality.
Also called: SSH File Transfer Protocol, SSH file transfer
SSH File Transfer Protocol supports remote file operations over an SSH connection. Clients can transfer files and perform operations such as listing directories or renaming files. SSH supplies the protected transport and peer authentication; the server’s account permissions still determine which files the client may access.
For example, a deployment job can upload a release archive to a server and rename it once the transfer finishes. SFTP is a different protocol from FTP, despite the similar names. FTPS means FTP protected with TLS, while SFTP normally uses SSH. An FTP-only service cannot understand SFTP simply because encryption is enabled.
SFTP sends file operations such as upload and rename over SSH. Server file permissions still apply, and these example operations do not promise a transaction covering the whole transfer. FTPS is the separate FTP-with-TLS approach.
Also called: File Transfer Protocol, FTP control and data connections
File Transfer Protocol transfers files using separate control and data connections. The control connection carries commands and replies; data connections carry file contents or directory listings. In active mode the server opens the data connection toward the client, while in passive mode the client connects to a server-provided endpoint.
For example, downloading a report can involve one connection to request the file and another to receive its bytes. This separation matters when firewalls or address translation block the negotiated data path. Base FTP does not encrypt credentials or file contents. FTPS adds TLS protection; SFTP belongs to the separate SSH family.
FTP keeps a control connection separate from data connections. Active and passive arrows show who initiates a data connection, not which way file contents must travel. Negotiated endpoints vary; base FTP does not encrypt its credentials or data.
Also called: Server Message Block, SMB 2, SMB 3, network file sharing
Server Message Block is a family of protocols for accessing shared resources, especially files and directories, across a network. Modern SMB 2 and SMB 3 clients negotiate a dialect, establish an authenticated session, and request operations such as opening, reading, writing, and closing a file. Sharing involves more than copying a complete file once.
For example, an office application can open a document on a shared folder and write selected changes through SMB. Access checks and coordination help multiple clients use the resource. Available signing, encryption, and caching features depend on the negotiated dialect and configuration; the name SMB alone does not specify those protections.
SMB 2/3 clients negotiate a dialect and authenticate before operating on a shared server resource. The example session opens, reads, writes and closes a file. Access and sharing rules still apply; encryption depends on the negotiated features and configuration.
Operations and network tunnels
Clock synchronization, operational telemetry, and ways to carry or protect traffic across networks.
Also called: Network Time Protocol, NTPv4, network clock synchronization
Network Time Protocol estimates how a computer’s clock differs from time sources and helps adjust it. An exchange uses four timestamps: client send, server receive, server send, and client receive. Together they estimate clock offset and network round-trip delay while accounting for the time spent processing the request at the server.
For example, servers can synchronize clocks so logs from different machines are easier to compare. Repeated measurements and clock-selection algorithms improve the estimate, but unequal delays in the two directions introduce uncertainty. NTP does not discover exact time by simply halving a round trip, and synchronized timestamps alone cannot prove the causal order of closely spaced events.
Illustrative clock readings T1=0, T2=15, T3=16 and T4=21 milliseconds give an estimated server offset of +5 ms and a 20 ms network round trip after subtracting 1 ms server processing. The offset assumes symmetric path delays; the timeline spacing is schematic.
Precision Time Protocol synchronizes clocks in networked systems that need closely coordinated timing, such as industrial measurement or communication equipment. IEEE 1588 defines the protocol, and profiles adapt it to particular environments. Devices synchronize through a hierarchy whose reference is a grandmaster clock; timestamp placement and network behavior affect the achievable precision.
For example, cameras on a production line can align their timestamps so measurements refer to the same stage of an object’s movement. Such results depend on the designed network and equipment, rather than following automatically from enabling PTP. Synchronizing devices to each other also does not by itself establish an external UTC time reference.
Illustrative PTP hierarchy: a grandmaster coordinates measurement-device clocks through a designed network. Matching event labels show relative synchronization, not a promised accuracy. Traceability to external time such as UTC requires the separate reference input and appropriate implementation.
Also called: Simple Network Management Protocol, SNMPv3, MIB
Simple Network Management Protocol lets management software inspect and, when authorized, change device information. Managed variables have object identifiers and definitions in a Management Information Base, or MIB. Requests retrieve or update values, while notifications report events without waiting for the next poll.
For example, a monitor can read a switch’s interface counters and receive a link-down notification. Security depends on version and configuration. SNMPv3 distinguishes noAuthNoPriv, authNoPriv, and authPriv: no authentication or privacy, authentication without privacy, and authentication with privacy. Merely saying a device uses SNMPv3 does not establish that its management traffic is encrypted or that every operation is permitted.
An SNMP manager reads an illustrative interface counter and can separately receive a link-down notification. SNMPv3 security levels differ: only authPriv among those shown supplies both authentication and privacy. MIB definitions describe the variables; authorization remains separate.
Syslog provides a protocol and message structure for sending event records from applications or devices to collectors, sometimes through relays. The RFC 5424 format separates a header, structured data, and an optional message. Fields identify information such as severity, timestamp, host, and application so a collector can organize records from many sources.
For example, a router can report a failed login to a central log service. The message format and its transport are distinct: UDP, TLS-based transport, and other mappings have different delivery and protection properties. A familiar syslog-looking line therefore does not by itself prove reliable delivery, confidentiality, or compatibility with RFC 5424.
Syslog sends structured event records from originators to collectors, optionally through relays. Its header, structured data and optional message describe the format. A separately selected transport determines further delivery and protection properties; some header values may be unavailable.
Also called: OpenTelemetry Protocol, OTLP/gRPC, OTLP/HTTP
OpenTelemetry Protocol transports telemetry between applications, collectors, and backend services. It defines export requests, responses, and data schemas for signals such as traces, metrics, and logs. Its gRPC and HTTP variants carry the same kinds of telemetry through different protocol bindings; the HTTP variant supports binary or JSON Protocol Buffers encoding.
For example, a checkout service can export a batch of trace spans to a collector, which forwards them onward. The collector’s acknowledgment concerns that hop, not guaranteed final storage across the entire pipeline. Export responses can report partial acceptance, and retry rules distinguish temporary failures from data that should not be resent unchanged.
OTLP exports telemetry and returns a response on each adjacent hop. The illustrative partial-success batch has three accepted spans and one rejected span; it should not be retried wholesale as though nothing was accepted. A collector response does not prove final backend storage.
Also called: Internet Protocol Security, ESP, IPsec tunnel mode
IPsec is a suite for protecting IP traffic according to configured security policies. Security associations specify how traffic is protected between endpoints. Its mechanisms include ESP, which can provide encryption and integrity, and AH, which provides authentication and integrity without encryption. The chosen services and modes determine what is covered.
For example, two office gateways can use ESP tunnel mode to carry protected inner IP packets inside packets addressed to the gateways. Transport mode instead protects traffic within an existing IP packet without adding that same inner-and-outer addressing structure. A tunnel protects selected traffic between its endpoints; it does not automatically authorize every application behind them.
Conceptual ESP comparison with confidentiality and integrity selected. Tunnel mode carries a protected inner IP packet inside a visible outer routing header; transport mode protects the original IP payload without the same inner/outer address structure. AH does not provide encryption.
Also called: WireGuard tunnel, cryptokey routing, AllowedIPs
WireGuard is a VPN protocol and implementation that carries protected IP packets over UDP. Peers authenticate using configured public keys and establish session keys for traffic protection. Each peer is associated with allowed tunnel addresses: these help select the peer for outgoing packets and check source addresses on incoming packets.
For example, a laptop can route a private office subnet through a configured WireGuard peer. Only traffic selected by routing and peer configuration uses that tunnel; other traffic can take another path. Key distribution and user-account management are separate concerns. WireGuard and IPsec are different approaches to network protection, rather than interchangeable names for one protocol.
Illustrative routing sends the office subnet through a configured WireGuard peer while unrelated traffic uses another route. WireGuard protects inner IP packets over UDP. AllowedIPs selects outbound peers by destination and checks inbound source addresses; private keys are not transmitted.
Also called: Virtual Extensible LAN, VXLAN Network Identifier, VNI, VTEP
VXLAN carries Ethernet frames across an IP network by encapsulating them inside UDP packets. Tunnel endpoints, called VTEPs, add and remove the outer headers. A 24-bit VXLAN Network Identifier identifies the overlay segment, allowing separate virtual networks to share the same underlying network infrastructure.
For example, virtual machines on different racks can belong to one logical Ethernet segment even though routers connect the racks. The underlying network forwards outer IP packets between VTEPs, which recover the original frames. VXLAN adds packet overhead and does not itself encrypt traffic; segmentation identifiers alone are not cryptographic protection against an untrusted participant.
VXLAN VTEPs wrap an inner Ethernet frame with a VXLAN header, UDP and outer IP for transport across the underlay, then recover the frame. The illustrative VNI 42 identifies an overlay segment. Added headers consume space; VXLAN itself does not encrypt the frame.
Developer tools and integrations
Shared contracts that connect editors, debuggers, AI tools, repositories and artifact registries.
JSON-RPC defines a compact request-and-response convention using JSON objects. A request names a method, can include parameters, and normally carries an ID that the response echoes. A response contains either a result or an error. The protocol does not prescribe a particular network transport.
A client could request an illustrative add operation with parameters 2 and 3 and ID 7, then match a result of 5 to that ID. A notification omits the ID and receives no JSON-RPC response. An ID matches exchanges; it does not by itself prevent a repeated call from repeating its effects.
The Language Server Protocol connects an editor to a service that understands a programming language. It standardizes exchanges for features such as completion, diagnostics and navigation, so language support can be reused across editors. The base protocol carries JSON-RPC messages with headers that delimit their encoded content.
An editor can announce a changed document and ask for completions at the cursor. The server analyzes the document and returns suggestions, while the editor controls their presentation. In the inspected 3.18 specification, initialization exchanges capability information; a client should use supported features rather than assume every server implements every optional operation.
The Debug Adapter Protocol standardizes communication between a development tool’s debugging interface and an adapter for a debugger or runtime. The adapter translates operations such as setting breakpoints or inspecting variables into the underlying debugger’s commands. This separates the editor integration from debugger-specific details.
When execution pauses at a breakpoint, an adapter can send a stopped event; the editor can then request stack frames and variable values. DAP uses framed JSON messages with requests, responses and events, but its message schema is not JSON-RPC. Capabilities describe optional behavior, so support varies between adapters.
The Model Context Protocol connects AI applications with services exposing tools, resources and reusable prompts. A host application uses clients to communicate with servers through JSON-RPC-based messages. The protocol defines the exchange; the application still decides which capabilities are allowed and how their results are used.
An assistant could discover a documentation-search tool, call it with a query, and receive matching passages. In the inspected 2026-07-28 revision, requests carry their own protocol version and capability metadata. Older revisions use different lifecycle rules. A compatible tool response remains external input, not a guarantee that its contents are accurate or authorized instructions.
An MCP transport specifies how protocol messages travel while preserving their meaning. The inspected 2026-07-28 revision defines stdio for a client-launched subprocess and Streamable HTTP for an HTTP endpoint. Both carry UTF-8 JSON-RPC messages, but their framing and cancellation mechanisms differ.
A local tool server can read newline-delimited messages from standard input and write replies to standard output. A remote tool call uses an HTTP POST whose response is either a JSON object or a request-scoped server-sent event stream. Older MCP revisions have different HTTP and session rules, so implementations must agree on the revision rather than copy incompatible examples.
Also called: Git protocol v2, Git smart protocol, fetch negotiation
Git wire protocols let a client and server exchange repository information and objects. They are distinct from Git’s local object storage and can be carried over transports such as SSH or HTTP. Protocol version 2 organizes supported fetch-side operations as commands with advertised capabilities.
During a fetch, a client can discover references and negotiate which objects it needs using what it already has. The server sends the required object data in a packfile. This saves sending every object on each update. Version negotiation and packet-line framing govern the conversation; a successful network transfer alone does not decide how branches should be merged locally.
Also called: OCI registry protocol, container registry API
The Open Container Initiative Distribution Specification defines an HTTP API for moving content between clients and registries. Container images are a common use, but the distribution protocol is not limited to that content type. Manifests describe content, blobs hold bytes, and digests identify content by a cryptographic hash.
When pulling an image, a client can retrieve a manifest and then fetch the referenced configuration and layer blobs. A human-readable tag points to a manifest and can change, while a digest identifies particular content. Checking a digest detects a content mismatch; deciding whether a publisher is trustworthy requires additional policy or verification.
Also called: Web Distributed Authoring and Versioning, DAV
WebDAV extends HTTP with operations for managing remote resources, collections, properties and locks. It can make a server’s resources feel like a shared filesystem, while retaining HTTP request and response semantics. A server advertises the WebDAV capabilities it supports; not every installation supports every extension.
A client might create a collection with MKCOL, inspect properties with PROPFIND, and move a document with MOVE. A supported lock can help coordinate edits, subject to the server’s rules. Despite the name, the base WebDAV specification does not provide a complete version-control system; version history and access-control extensions are separate specifications.
WebDAV adds remote authoring operations to HTTP. Collections and properties are part of the base model; version-control features need additional support.
Language and debugging operations
How editors synchronize source text, request language intelligence and inspect paused programs through LSP and DAP.
Also called: initialize request, initialized notification
LSP initialization establishes which editor and language-server features can work together. In the inspected 3.18 specification, the editor sends initialize with its capabilities and receives the server’s capabilities. Optional features need explicit support; connecting to a language server does not imply that every language operation is available.
For example, a server can advertise completion support while leaving semantic tokens unavailable. After the initialize response, the editor sends the initialized notification before ordinary feature requests. This ordering gives both sides a shared starting point, while later capability registration can adjust supported features where the client permits it.
Document synchronization keeps a language server’s view aligned with the text being edited, including changes not yet saved to disk. LSP uses document URIs, version numbers and open, change and close notifications. The agreed synchronization mode determines whether a change sends the whole document or an incremental edit. These document versions are unrelated to the LSP revision.
Suppose version 7 contains count=1. An incremental change can replace the final character with 2 and identify the resulting document as version 8. Later analysis should use that updated text. Multiple edits within one change notification apply in sequence, so each edit’s range refers to the document produced by the preceding edit.
Diagnostics describe problems associated with a document, such as a syntax error or an unused variable. They carry ranges and messages, with optional information such as severity and codes. LSP 3.18 supports server-published diagnostics and a capability-dependent model in which the editor requests diagnostic reports.
In the publishing model, a new diagnostic list replaces the previous list for that document. If fixing a missing bracket removes the only error, the server sends an empty list to clear the editor’s marker. Sending nothing would leave the old report in place. This replacement rule matters when updates arrive repeatedly while someone types.
Also called: textDocument/completion, completionItem/resolve
Completion asks a language server for useful suggestions at a document position. The server can return items with labels, insertion text or edits, and hints for sorting or filtering. The editor presents those options; a suggestion does not change the document merely because the server returned it.
For example, typing pri can produce a print suggestion. If supported, selecting that item can trigger completionItem/resolve to fetch documentation. By default, only detail and documentation can be filled in later; clients can explicitly permit other properties. Any property outside that declared set must already be supplied and remain unchanged. The editor applies the suggestion when the user accepts it.
Also called: semantic highlighting, semantic token legend
Semantic tokens let a language server describe the roles of pieces of source code, such as a variable, a function or a class. The editor maps those roles to its theme. This can distinguish names that look alike to a simple text scanner but have different meanings in the program.
In total = add(2, 3), a server might identify total as a variable and add as a function. LSP encodes token positions and refers to a server-declared legend of token types and modifiers. Supported delta updates can send changes to an earlier token result, reducing repeated data. The protocol describes meaning and positions; it does not prescribe the colors shown to the reader.
The Debug Adapter Protocol lets an editor configure breakpoints through a debug adapter. For source breakpoints, setBreakpoints sends the complete desired list for one source file. It replaces that file’s previous list, so removing a breakpoint means sending the remaining list, or an empty list to remove them all.
Suppose checkout.py has breakpoints on lines 10 and 20. Sending only line 20 removes the line-10 breakpoint. The adapter’s response reports whether each requested breakpoint could be set and can identify a different actual location. Conditional breakpoints require the corresponding capability. These are DAP JSON requests and responses, using DAP’s own message structure rather than a JSON-RPC envelope.
Also called: stackTrace, scopes request, variablesReference
When a program pauses, a debugger can describe the active function calls as stack frames. In DAP, an editor requests stackTrace for a thread and receives frames with names, source positions and identifiers. Selecting a frame provides the context for inspecting that call’s local variables.
A paused checkout might have calculate above checkout above main. The editor uses the calculate frame ID in a scopes request, then uses a returned variablesReference to request the values inside its local scope. These handles describe the paused execution state; they are not permanent object identities. After execution resumes and stops again, the editor must obtain fresh state rather than reuse stale variable handles.
Also called: one-way JSON-RPC message, notification request
A JSON-RPC 2.0 notification is a request without an id member. The receiver must not send a JSON-RPC response, even when the notification encounters an error. Notifications suit information that does not need a matching protocol reply, such as an editor announcing a document change.
An illustrative cursorMoved notification could carry a line number without an ID. The sender cannot use silence to conclude that the application processed it successfully. A transport may still acknowledge delivery of bytes, but that is different from an application result. If the sender needs a result or a reportable error, it should use a request with an ID instead.
Tool discovery tells an MCP client which named operations a server exposes and how to supply their arguments. In the inspected 2026-07-28 revision, tools/list returns tool descriptions and input schemas, with pagination when the catalog spans multiple pages. A tool description is information about an operation, not an execution of it.
A document service might advertise search_notes with a required query string. The client can use that schema to form a later call. Available tools may depend on the authorization supplied with the request, so one user’s catalog is not necessarily valid for another. Finding a tool also does not remove the server’s responsibility to authorize its eventual invocation.
An MCP tool invocation requests a named operation with arguments. The 2026-07-28 tools/call method can return content for the host to consume and optional structured data. The host decides how to present or use that output; receiving tool text does not make it a higher-priority instruction.
For example, search_notes with query set to invoices could return matching note titles. A completed tool operation can report a domain failure through isError in its result, while an unknown tool can produce a protocol error. A completed result therefore needs interpretation, not merely a successful message exchange. Some operations instead request additional input before they can finish.
Also called: resources/list, resources/read, resource URI
MCP resources expose contextual data under URIs, such as a document, database schema or image. A client can discover listed resources and request their contents through resources/read. Returned content may be text or binary data. The host application decides which retrieved material to show or include in a model’s context.
For example, a project service could expose project://catalog/schema as a resource describing its tables. Reading that URI asks the service for the data; it does not imply access to an identically named file on the user’s computer. In the inspected 2026-07-28 revision, resource discovery and reading remain distinct operations, and available data depends on the server’s implementation and access controls.
Also called: prompts/list, prompts/get, prompt template
MCP prompts are server-provided templates that produce structured messages for an application. A client can discover named prompts with prompts/list and retrieve a selected prompt with prompts/get, supplying any required arguments. This makes reusable interaction patterns available without embedding each template directly into every client.
A code-review prompt might accept a programming language and return messages asking for an explanation of potential bugs. Retrieving those messages does not itself run the review, execute a tool or override the host’s instructions. The host decides how to present and use the template. This description follows the inspected 2026-07-28 revision, in which prompt retrieval can also request additional input.
MCP authorization controls access to a protected server. For HTTP, the inspected 2026-07-28 revision defines an OAuth-based arrangement: the MCP server is the protected resource, an authorization server issues access tokens, and the client presents an appropriate token with each protected request. This framework is optional for MCP implementations overall.
A notes client might discover the service’s authorization server through protected-resource metadata, then obtain permission to read notes. A token for another service must not be accepted merely because it looks valid. Requested scopes should match the needed access. The HTTP flow is separate from local stdio credential handling, and the referenced OAuth 2.1 document remains a draft in this MCP revision.
Also called: server/discover, MCP request metadata
MCP capability information tells a client which server facilities and extensions it can use. In the inspected 2026-07-28 revision, an optional server/discover call returns supported protocol versions and server capabilities. Each request carries its protocol version and client capabilities in metadata; client information is recommended but optional. There is no required initialization handshake.
For example, a client can discover support for tools but not prompts, then choose an appropriate operation. It can also call a method directly and handle an unsupported-version response. Extension use must respect both sides’ advertised support. These declarations describe protocol abilities; they do not authenticate the server or authorize access to a particular tool.
Also called: notifications/cancelled, MCP request cancellation
Cancellation tells an MCP server that a client no longer wants an in-progress operation. In the inspected 2026-07-28 revision, the signal depends on the transport: stdio uses notifications/cancelled with the request ID, while Streamable HTTP uses closure of that request’s SSE response stream. The client should stop waiting after cancellation.
For example, a user abandoning a long search can release the stream carrying its results. Cancellation can race with completion, so it does not prove that work never happened or undo an action already performed. A server may be unable to stop some operations. Timeouts provide another reason to cancel, but applications still need separate rules for any side effects.
Also called: input_required, multi-roundtrip requests, MRTR
Some MCP operations need additional information before returning their final result. In the inspected 2026-07-28 revision, a tool call, resource read or prompt retrieval can return resultType input_required with named input requests. The client gathers the requested input and retries the original operation with corresponding inputResponses.
For example, an export tool could ask the user to choose a destination folder. The retry carries that choice and any opaque requestState supplied by the server. The server must validate returned state rather than trust it because it passed through the client. This is a sequence of independent client-initiated exchanges, not a separate server-initiated JSON-RPC request awaiting a reply.
Also called: request timeout, deadline, time budget
A timeout limits how long an operation may wait; a deadline specifies the point in time after which its result is no longer wanted. Protocol clients use these limits to bound resource use and latency. Connection establishment, reading a response and completing an entire operation can have different limits.
Suppose a checkout request has a two-second budget. If earlier work consumes 1.5 seconds, a downstream call should receive the remaining budget rather than another full two seconds. Expiry tells the caller to stop waiting, not that remote side effects never occurred. Cancellation can reduce wasted work, but the server application must cooperate and already completed work is not automatically undone.
Also called: exponential backoff, retry jitter, bounded retries
A retry repeats an operation after a failure that may be temporary. Backoff increases the delay between attempts; jitter varies that delay to stop many clients retrying in lockstep. A retry policy also needs limits on attempts or total time and rules identifying which failures are worth retrying.
A hypothetical client could use increasing delay ceilings of 100, 200 and 400 milliseconds, selecting a random wait within each range. These numbers illustrate the pattern rather than recommended defaults. Retrying overload can make it worse, and repeating an operation with side effects requires an idempotent design or another way to determine whether it already succeeded.
Also called: deduplication key, client request token
An idempotency key identifies one intended operation across repeated requests. A supporting server records or coordinates the operation under that key so that a retry does not simply execute it again. Its contract must define scope, retention, parameter matching and what happens when requests overlap.
After a create-order response is lost, a client can repeat the same request with the same key and obtain the already-created order under a suitable API contract. A genuinely new order needs a new key. Sending a random header to an unsupported endpoint provides no protection, and reusing a key after its record expires may create a new operation.
Also called: request ID, trace ID, request correlation
A correlation ID connects messages or records belonging to the same exchange or operation. A request/response protocol may echo a request ID; a distributed tracing system propagates trace context across services. The identifier’s meaning and propagation rules are part of the chosen protocol or application convention.
A checkout request passing through an API, inventory service and payment service can keep one trace ID while individual spans receive different IDs. Engineers can then find the related records together. A correlation identifier is not an authorization credential or an idempotency key: matching two records does not permit access or suppress duplicate effects.
A heartbeat is a periodic message used to observe whether a peer or connection still responds. Keepalive traffic can also prevent some idle connections from being discarded. The protocol defines the expected reply, timing and action when responses do not arrive; different layers can use different mechanisms.
For example, gRPC can use HTTP/2 PING frames and their acknowledgments on a long-lived connection. A missed reply may reflect a broken path, a stalled peer or delay; it is not perfect proof that the remote process has died. A successful reply shows connection responsiveness, not necessarily that the application’s database or business operations are healthy.
Also called: producer throttling, downstream demand
Backpressure propagates a downstream capacity limit upstream so that a producer slows, pauses or limits outstanding work. It can use demand signals, credits, bounded buffers or blocked writes. Transport flow control is one mechanism, but application queues also need a policy for work that arrives faster than it can be processed.
If a producer offers 100 messages per second while a consumer handles 40, an unbounded queue would grow by 60 messages per second while those rates persist. Backpressure can make the producer wait as capacity fills. It does not create extra processing capacity; the system still needs to decide what to delay, reject or discard when demand exceeds its limits.
Also called: conformance testing, MUST SHOULD MAY, interoperability testing
Protocol conformance means meeting a specification’s applicable requirements, including message formats, state transitions and error behavior. Specifications using BCP 14 distinguish mandatory MUST requirements, SHOULD recommendations with carefully considered exceptions, and optional MAY features. The document’s own conformance rules determine what an implementation can claim.
A parser that accepts a valid request but mishandles a malformed one can still violate the protocol. Useful tests cover successful exchanges, boundary values and required rejection behavior, followed by exchanges with independent implementations. Passing a test suite is evidence about its coverage, not proof of every possible behavior; optional capabilities must also be handled consistently.
Also called: extension mechanism, forward compatibility, capability negotiation
Protocol extensibility is the ability to add features through defined rules while preserving useful communication between implementations. Extension identifiers, lengths, capability advertisements and handling rules for unknown fields can make evolution predictable. Compatibility depends on semantics as well as the ability to parse new bytes.
A hypothetical message format could allow unknown optional fields to be skipped using their lengths, while rejecting an unknown field marked critical. Another protocol might require negotiating a feature before use. Neither policy is universal: silently accepting every unknown input can hide errors, and rejecting every addition can prevent planned evolution. The protocol must specify which behavior applies.