Protocols
Saved & recent

Protocols glossary

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.

Protocol fundamentals

The agreements that let independently written programs exchange meaningful messages.

Protocol

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.

client program server program LOOKUP item=7 RESULT stock=12 format meaning sequence shared protocol contract hypothetical inventory exchange
Hypothetical inventory exchange: independent programs follow the same rules for message format, meaning, and sequence.

Protocol stack

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.

Read first
Protocol
Ethernet IP TCP HTTP/1.1 Ethernet IP TCP HTTP/1.1 internet transport application sender receiver logicalpeers physical link down up
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

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.

Read first
Protocol stack
Schematic nesting; widths do not represent byte counts. Adding an envelope does not encrypt its contents.

Message framing

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.

Read first
Protocol
Schematic DNS-over-TCP framing: length fields count message bytes only. Network reads need not align with message boundaries.

Serialization

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.

Read first
Protocol
Illustrative reading: JSON carries the value; the application’s field agreement gives it a unit and meaning.

Protocol state machine

Also called: finite-state machine, FSM

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.

Read first
Protocol
Hypothetical session state machine. Event labels explain why a transition occurs; actual protocols often need more states.

Version negotiation

Also called: protocol version negotiation

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.

Read first
Protocol
Hypothetical support sets share version 2. The protocol must define both selection and the no-common-version outcome.

End-to-end principle

Also called: end-to-end argument

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.

Read first
Protocol stack
Illustrative integrity check from the original file to the saved copy. A plain checksum is not sender authentication.

Encoding and protocol evolution

How protocols represent structured data, preserve meaning across versions and keep room for new capabilities.

Type–length–value

Also called: TLV, tag-length-value

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.

Read first
Message framing
In this illustrative TLV format, the length counts three value bytes; the type and length add two more bytes.

Concise Binary Object Representation

Also called: CBOR, RFC 8949

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.

Read first
Serialization
CBOR encodes this three-integer array in four bytes; application meaning still comes from a shared contract.

MessagePack

Also called: MessagePack serialization, msgpack

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.

Read first
Serialization
MessagePack’s 93 array header differs from CBOR’s 83 even when the values being represented are identical.

Apache Avro

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.

Read first
Serialization
Avro interprets a record’s compact values using its writer schema, which may be carried in container metadata or supplied separately.

Schema evolution

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.

Read first
Serialization
A new field can preserve binary decoding in both deployment directions while still changing what the application needs to understand.

Capability negotiation

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.

An agreed negotiation rule selects shared functionality; unsupported features and access permissions require separate handling.

Protocol greasing

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.

A GREASE offer keeps the unknown-option path exercised while the server selects a real mutually supported choice.

Canonicalization

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.

Read first
Serialization
Under the same JCS rules, these differently formatted objects produce identical canonical bytes for hashing or signing.

Internet addressing and routing

How packets identify destinations, cross networks, and report delivery problems.

Internet Protocol

Also called: IP, Internet layer

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.

Read first
Protocol stack
Illustrative route across several networks. IP forwarding is best effort; loss recovery belongs to other mechanisms.

IPv4

Also called: Internet Protocol version 4

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.

Documentation example: four eight-bit groups make a 32-bit IPv4 address.

IPv6

Also called: Internet Protocol version 6

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.

Documentation example expanded into eight 16-bit groups. One double colon abbreviates the consecutive zero groups.

IP address and subnet

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.

IPv4 addresses in a /p block = 232 − p

Read first
IPv4
Related
IPv4, IPv6, Routing
Documentation block: 26 fixed bits leave six variable bits, giving 64 addresses. Usable-host counts are a separate question.

Routing

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.

Illustrative forwarding table: the matching /26 route wins because it has the longest destination prefix.

ICMP

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.

Illustrative IPv6 diagnostic: a router discards a packet whose hop limit is exhausted and may return a Time Exceeded message.

Network address translation

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.

Read first
IPv4
Illustrative NAPT mapping. Address and port rewriting lets replies find the internal endpoint; payloads are not encrypted by this operation.

DHCP

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.

Typical initial DHCPv4 allocation. Renewing an existing lease can use a different exchange.

Routing and DNS trust

How networks exchange routes, choose service locations, cache names, and protect DNS exchanges.

BGP

Also called: Border Gateway Protocol, BGP-4

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.

Illustrative BGP choice: local policy can prefer one advertised route even when another path appears shorter.

Autonomous system

Also called: AS, autonomous system number, ASN

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.

Read first
Routing
Illustrative routing domains: an autonomous system groups networks behind a coherent external routing policy.

OSPF

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.

Read first
Routing
Illustrative OSPF costs: the path totaling 4 wins over the alternative totaling 7.

Anycast

Also called: IP anycast, anycast service

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.

Read first
Routing
Related
BGP, DNS, TCP
Illustrative anycast service: the same address is available at multiple sites, and routing selects where each packet goes.

DNS TTL

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.

Read first
DNS resolution
Illustrative cache lifetime: a 300-second TTL counts down locally, while an authoritative change does not erase existing cached copies.

DNSSEC

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.

Read first
DNS resolution
Schematic DNSSEC validation: a chain of trust supports checks on signed DNS data, without concealing the query itself.

DNS over HTTPS

Also called: DoH, encrypted DNS over HTTPS

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.

Read first
DNS, HTTPS
Illustrative DoH boundary: HTTPS protects the client-to-resolver exchange, while the resolver still processes the DNS question.

DNS over TLS

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.

Read first
DNS, TLS
Illustrative DoT connection: multiple framed DNS exchanges share an authenticated TLS channel to the selected resolver.

Transport and naming

How applications move bytes and messages, manage sending rates, and resolve names.

TCP

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.

Illustrative stream reads: TCP preserves byte order, while read boundaries can differ from the sender’s writes.

TCP handshake

Also called: three-way handshake, SYN SYN-ACK ACK

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.

Read first
TCP
Ordinary opening without application data. Starting numbers are illustrative; each SYN advances its sender’s sequence space by one.

UDP

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.

Hypothetical sensor exchange: UDP preserves messages but does not fill the gap when datagram 13 is lost.

QUIC

Also called: QUIC transport

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.

Read first
UDP
Illustrative loss on stream A need not block stream B’s delivery. Streams still share the connection’s network capacity.

DNS

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.

Illustrative records, not live DNS answers. The requested record type determines what kind of information is returned.

DNS resolution

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.

Read first
DNS
Related
DNS, UDP, TCP
Simplified cache miss: the recursive resolver follows referrals. A valid cached answer can avoid this sequence.

Flow control

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.

Read first
TCP
Simplified credit model: four free buffer slots permit four more chunks. Real TCP advertises a byte window, and congestion limits also apply.

Congestion control

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.

Conceptual bottleneck: reducing offered traffic can let a network queue drain even when the receiver has spare capacity.

TCP vs UDP

TCPUDP
DefinitionA connection-oriented transport providing an ordered byte stream with loss detection and retransmission.A datagram transport that preserves message boundaries without providing delivery or ordering guarantees.
Data shapeA stream of bytes. Applications define their own message boundaries.Separate datagrams. Each datagram has its own boundary.
Ordering and lossDelivers stream bytes in order and retransmits lost data; a connection can still fail.Datagrams may be lost, duplicated, or arrive out of order. UDP does not repair these events.
Connection setupOrdinary connections begin with a three-way handshake.UDP has no transport-level connection handshake.
Application responsibilitiesChoose message framing and handle connection failure.Choose any required recovery, ordering, and congestion-management behavior, often through a higher-level protocol such as QUIC.

Transport mechanics

How software addresses endpoints, detects damage, recovers gaps, and trades handshake delay against replay risk.

Transport port

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.

Read first
TCP, UDP
Illustrative TCP conversation: source and destination ports reverse in replies, while the transport and IP addresses also help identify the endpoints.

Socket

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.

Read first
Transport port
Related
TCP, UDP, WebSocket
Illustrative server API: one listening socket accepts clients and returns a separate connected socket for each connection.

Checksum

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.

Read first
Encapsulation
Related
TCP, UDP, TLS
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.

IP fragmentation

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.

Illustrative IPv4 fragmentation with no header options and fragmentation allowed: the 2,000-byte payload splits into 1,480- and 520-byte pieces.

Selective acknowledgment

Also called: SACK, TCP SACK, SACK block

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.

Read first
TCP
Illustrative TCP feedback: the cumulative ACK marks the gap, while a SACK block reports later bytes already received.

Head-of-line blocking

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.

Read first
TCP
Related
HTTP/2, QUIC, HTTP/3
Schematic transport comparison: QUIC separates stream delivery order, while each stream still waits for its own missing bytes.

TCP keepalive

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.

Read first
TCP
Illustrative limit of TCP keepalive: a responding network stack can coexist with an application that is unable to serve requests.

0-RTT early data

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.

Read first
TLS handshake
Illustrative early-data policy: an eligible request can leave with the first handshake flight, while replay-sensitive work waits.

HTTP semantics

Requests, responses and the shared rules that give web messages meaning.

HTTP

Also called: Hypertext Transfer Protocol

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.

Schematic HTTP exchange: the client asks for /terms/tcp with GET; the server returns status 200 and an HTML representation.

HTTP methods

Also called: HTTP verbs, request methods

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.

Read first
HTTP
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.

HTTP status codes

Also called: HTTP response codes

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.

Read first
HTTP
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.

HTTP headers

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.

Read first
HTTP
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.

Safe HTTP methods

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.

Read first
HTTP methods
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.

Idempotency

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.

Read first
HTTP methods
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.

Content negotiation

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.

Read first
HTTP headers
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.

Conditional requests

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.

Read first
HTTP headers
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

Also called: HTTP 1.1, persistent HTTP connection

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.

Read first
HTTP
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

Also called: HTTP 2, HTTP multiplexing, h2

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.

Read first
HTTP, TCP
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

Also called: HTTP 3, h3

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.

Read first
HTTP, QUIC
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

Also called: HTTP Secure, HTTP over TLS

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.

Read first
HTTP, TLS
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.

HTTP caching

Also called: HTTP cache, Cache-Control, freshness

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.

Read first
HTTP headers
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.

HTTP cookies

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.

Read first
HTTP headers
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.

CORS

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.

Read first
HTTP headers
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.

Web proxy

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.

Read first
HTTP
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 vs WebSocket

HTTPWebSocket
DefinitionA family of application-level request/response protocols with shared methods, status codes, and representation semantics.An application protocol for two-way messages over an established connection. RFC 6455 defines an opening handshake followed by message framing.
Message modelA client sends a request and a server returns a response. A response body can stream.After establishment, either endpoint can send messages without a new HTTP request for each message.
Built-in semanticsStandard methods, status codes, headers, and rules for representations and caching.Text/binary message framing and control frames; application message meanings are defined by the application.
Connection useConnections can be reused; a request does not inherently require a fresh connection.An opening handshake establishes the channel for subsequent messages.
A useful starting pointResource retrieval and APIs that benefit from standard request/response semantics.Ongoing two-way exchanges such as collaborative updates; the application still needs to define reconnection and message handling.

HTTP operations

Practical HTTP mechanisms for credentials, partial results, errors, redirects and request limits.

HTTP authentication

Also called: HTTP auth, authentication challenge

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.

Read first
HTTP
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.

Bearer token

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.

Read first
Authentication
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.

HTTP range requests

Also called: byte-range request, partial content

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.

Read first
HTTP
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

Also called: request throttling, API rate limit

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.

Read first
HTTP
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

Also called: RFC 9457, application/problem+json

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.

Read first
HTTP
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

Also called: paged results, continuation token

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.

Read first
HTTP
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.

HTTP redirects

Also called: HTTP redirection, Location redirect

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.

Read first
HTTP
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.

HTTP CONNECT

Also called: CONNECT method, HTTP tunnel

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.

Read first
HTTP
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.

REST

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.

Read first
HTTP
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.

Remote procedure call

Also called: RPC, remote call, client stub

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

Also called: Google RPC framework, gRPC streaming

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.

Protocol Buffers

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.

GraphQL

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.

OpenAPI

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.

Read first
HTTP
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.

Webhooks

Also called: HTTP callback, event webhook

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.

Read first
HTTP
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.

API versioning

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.

TLS

Also called: Transport Layer Security

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.

TLS handshake

Also called: TLS negotiation, TLS 1.3 handshake

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.

Read first
TLS
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.

Certificate

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.

Certificate authority

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.

Read first
Certificate
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.

Mutual TLS

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.

Read first
TLS, Certificate
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.

SSH

Also called: Secure Shell

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.

ALPN

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.

Read first
TLS
Related
SNI, HTTPS
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.

SNI

Also called: Server Name Indication

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.

Read first
TLS
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

Also called: authn, identity verification

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

Also called: authz, access control

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

Also called: OAuth, delegated authorization

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.

Read first
Authorization
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.

Authorization code flow

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.

Read first
OAuth 2.0
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.

PKCE

Also called: Proof Key for Code Exchange, S256

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.

Read first
OAuth 2.0
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

Also called: OIDC

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.

JWT

Also called: JSON Web 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.

SAML

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.

Read first
Authentication
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.

Session

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.

Read first
HTTP cookies
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.

Cross-site request forgery

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.

Read first
HTTP cookies
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.

Refresh token

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.

Read first
OAuth 2.0
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

Also called: OAuth token introspection, RFC 7662

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.

Read first
OAuth 2.0
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

Also called: OAuth token revocation, RFC 7009

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.

Read first
OAuth 2.0
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.

JSON Web Key Set

Also called: JWKS, JWK Set, JSON Web Keys

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.

Read first
JWT
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

Also called: JWT validation, claim validation

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.

Read first
JWT
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

Also called: Web Authentication, FIDO2 WebAuthn

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.

Read first
Authentication
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

Also called: pub/sub, pubsub

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.

Message broker

Also called: broker, messaging server

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

Also called: MQTT 5.0

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.

Further reading
OASIS MQTT Version 5.0
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.

AMQP

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 wire protocol

Also called: Apache Kafka protocol

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.

Delivery semantics

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.

Consumer acknowledgment

Also called: consumer ack, message acknowledgment

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.

Read first
Message broker
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.

Dead-letter queue

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.

Read first
Message broker
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

Also called: SOAP messaging, SOAP 1.2

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.

WSDL

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

Also called: Core NATS, NATS messaging, JetStream

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.

STOMP

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.

Read first
Message broker
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.

CoAP

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.

Schema registry

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.

Transactional outbox

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.

Consumer group

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

Also called: WebSockets, WS, WSS

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.

Read first
HTTP
An HTTP/1.1 opening handshake is followed by independently sent application messages. The connection stays available for both directions.

Server-sent events

Also called: SSE, EventSource, text/event-stream

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.

Read first
HTTP
One HTTP response can carry many events. Event IDs help a server resume a stream if that server retains the necessary history.

WebRTC

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.

The application supplies signaling. A working media path may be direct or relayed; WebRTC also supports data channels.

Session Description Protocol

Also called: SDP, session description

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.

A simplified session description configures a media exchange. Sending the description is separate from transporting the audio.

Interactive Connectivity Establishment

Also called: ICE, ICE candidates, candidate pair

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.

ICE tests candidate pairs and nominates a working one. A candidate address alone is not proof of connectivity.

Session Traversal Utilities for NAT

Also called: STUN, server-reflexive address

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.

A STUN server reports the endpoint it observes. This example uses a documentation address; reachability must still be checked.

Traversal Using Relays around NAT

Also called: TURN, TURN relay, relayed candidate

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.

TURN places a relay on the data path when needed. Allocation and refresh messages maintain the client’s relay address.

RTP and RTCP

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.

RTP sequence numbers expose a gap; RTCP reports describe delivery. A gap can reflect loss or reordering.

Real-time media and data

Signaling, protected media, message transport, and timing mechanisms for interactive communication.

SIP

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.

RTSP

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.

SRTP

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.

Read first
RTP and RTCP
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.

DTLS

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.

Read first
UDP, TLS
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.

SCTP

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.

WebRTC data channel

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.

Read first
WebRTC, SCTP
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.

Jitter buffer

Also called: de-jitter buffer, playout buffer

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.

WebTransport

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.

Read first
QUIC
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.

SMTP

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.

Email submission

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.

Read first
SMTP
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.

IMAP

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.

POP3

Also called: Post Office Protocol Version 3, POP

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.

MIME

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.

SFTP

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.

Read first
SSH
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.

FTP

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.

SMB

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.

NTP

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.

Related
PTP, Syslog, UDP
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.

PTP

Also called: Precision Time Protocol, IEEE 1588

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.

SNMP

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

Also called: syslog protocol, RFC 5424 logging

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.

Related
OTLP, NTP, UDP, TLS
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.

OTLP

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.

Read first
gRPC
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.

IPsec

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.

WireGuard

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.

VXLAN

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

Also called: JSON-RPC 2.0

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 response repeats request ID 7. A notification has no ID and receives no JSON-RPC response.

Language Server Protocol

Also called: LSP, language server

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.

Read first
JSON-RPC
A common protocol lets different editors reuse a language-server implementation. Available features depend on exchanged capabilities.

Debug Adapter Protocol

Also called: DAP, debug adapter

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 adapter bridges a shared debugging protocol to a particular debugger. Events report changes such as execution stopping.

Model Context Protocol

Also called: MCP

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.

Read first
JSON-RPC
MCP revision 2026-07-28 carries version and capability information with requests. The host governs how exposed capabilities are used.

MCP transports

Also called: MCP stdio, Streamable HTTP

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.

The same MCP meaning can travel over subprocess streams or HTTP. This diagram follows the 2026-07-28 transport revision.

Git wire protocols

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.

A simplified v2 fetch negotiates needed objects. Transfer and local branch integration are separate operations.

OCI Distribution Specification

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.

Read first
HTTP
An image manifest points to configuration and layer blobs. Tags name manifests; digests identify their content.

WebDAV

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.

Read first
HTTP
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.

LSP initialization

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.

LSP 3.18 exchanges capabilities during initialization before the editor starts ordinary language-feature requests.

LSP document synchronization

Also called: didOpen, didChange, didClose

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.

An incremental notification brings the server’s document to version 8 before subsequent analysis uses the changed text.

LSP diagnostics

Also called: publishDiagnostics, pull diagnostics

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.

Publishing an empty diagnostic list clears an earlier problem marker for the same document.

LSP completion

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.

Completion supplies insertion instructions; an optional resolve request can fetch documentation for the selected suggestion.

LSP semantic tokens

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 server identifies semantic roles, and the editor chooses how its theme displays them.

DAP breakpoints

Also called: setBreakpoints, source breakpoints

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.

Sending the desired line-20 breakpoint replaces the earlier list for checkout.py and removes its line-10 breakpoint.

DAP stack frames

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.

A frame ID selects a call; a separate variablesReference opens a scope’s values while execution remains paused.

JSON-RPC notifications

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.

Read first
JSON-RPC
A notification omits its ID and receives no JSON-RPC reply; a request uses an ID to match a result or error.

MCP capabilities and exchanges

Tools, resources, prompts and request patterns in the inspected 2026-07-28 revision of the Model Context Protocol.

MCP tool discovery

Also called: tools/list, tool input schema

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.

Discovery describes the tools visible to this caller; a separate request invokes a selected operation.

MCP tool invocation

Also called: tools/call, tool execution result

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.

A tool call returns an interpretable result; tool-level failures and protocol errors occupy different parts of the exchange.

MCP resources

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.

The client reads a URI-identified resource, then the host decides how the returned context should be used.

MCP prompts

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.

A retrieved prompt supplies reusable messages; the host controls whether and how to use them.

MCP authorization

Also called: MCP OAuth, protected MCP server

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.

A protected HTTP MCP service accepts a token issued for its own resources and checks the requested access.

MCP capability negotiation

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.

This MCP revision makes discovery optional and carries version and client capabilities independently on each request.

MCP cancellation

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.

Read first
MCP transports
Cancellation uses a request ID on stdio or a request-stream disconnect on HTTP, and can arrive after work has completed.

MCP input requests

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.

An input_required result asks the client to gather information and retry the original operation before it can complete.

Reliable exchanges and evolution

Time limits, retries, capacity signals and compatibility rules that make protocol implementations dependable.

Timeout

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.

A hypothetical two-second budget leaves only half a second after 1.5 seconds of earlier work. Timeout limits waiting, not prior effects.

Retry backoff and jitter

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.

Read first
Timeout
Increasing wait ceilings with randomized delays spread retries. A time or attempt limit stops retries from continuing indefinitely.

Idempotency key

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.

Read first
Idempotency
Under an API’s documented retention and matching rules, a retry reuses the key and retrieves the original operation’s result.

Correlation ID

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.

Further reading
W3C — Trace Context
A shared trace ID links related work while separate span IDs distinguish operations. The labels are schematic abbreviations.

Heartbeat and keepalive

Also called: heartbeat message, keepalive, PING

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.

Further reading
gRPC — Keepalive
An acknowledged PING tests the connection. Missing the configured deadline raises suspicion; service health needs a separate check.

Backpressure

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.

Further reading
gRPC — Flow Control
With the hypothetical rates shown, an unconstrained queue grows by 60 messages per second. Backpressure limits upstream production or admission.

Protocol conformance

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.

Conformance includes required error behavior. Interoperability tests add evidence from real exchanges with another implementation.

Protocol extensibility

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.

A hypothetical extension policy skips unknown optional fields but rejects unknown critical ones. Real protocols define their own rules.