Skip to Content

What do you mean by the REST?

Representational state transfer (REST) is an architectural style for building distributed systems based on hypermedia. REST aims to leverage existing protocols and features of the modern web in order to create an architecture that is performant, scalable, simple, modular, and reliable. The core ideas behind REST include:

Client-Server Architecture

REST systems have a separation between the client and server. Clients initiate requests to servers, which process requests and return appropriate responses. This helps improve scalability by simplifying the client side while enabling more complexity on the server side.


REST requires that client session state be held only on the client, and each request contain all necessary information for processing. This constraint helps scalability since no client context needs to be stored on the server between requests.


REST responses should ideally be cacheable to improve performance. Resources should be uniquely addressable via URIs to enable caching of responses.

Uniform Interface

REST defines a uniform interface between clients and servers that helps decouple the architecture. This interface is constrained by:

  • Resource identification through URIs
  • Resource manipulation through representations
  • Self-descriptive messages
  • Hypermedia as the engine of application state

Layered System

REST allows clients and servers to be composed into hierarchical layers to improve scalability through intermediary components like proxies, gateways, and caches.

Code on Demand (Optional)

REST allows client functionality to be extended dynamically by downloading and executing code. This simplifies clients and improves extensibility.

Benefits of REST

Some key benefits of RESTful architectures include:

  • Improved scalability and performance
  • Reliability through statelessness
  • Simplicity and modularity of components
  • Flexibility through loose coupling
  • Reusability through standardized interfaces

RESTful Principles

There are several guiding principles and best practices for building RESTful systems:

  • Use HTTP methods explicitly – GET, POST, PUT, DELETE etc.
  • Give resources unique URIs
  • Return JSON/XML representations
  • Use status codes meaningfully
  • Make resources HATEOAS driven
  • Use HTTP headers for caching, auth, content-type

Common REST Architectural Components

Some common components found in REST architectures include:

Component Description
Client Initiates requests and receives responses, e.g. browser, mobile app
Resource Data representation, e.g. document, image, service
Representation Serialized resource state, e.g. JSON, XML, PNG
URI Resource identifier, e.g.
Message HTTP request and response
Server Hosts resources and handles requests

REST Maturity Model

There are various levels of RESTful maturity for APIs and systems:

Level 0 – HTTP as transport

Using HTTP only as a transport protocol without leveraging its features.

Level 1 – Resources

Exposing resources with proper URIs.

Level 2 – HTTP verbs

Using HTTP methods explicitly for operations on resources.

Level 3 – Hypermedia controls

Using hypermedia for driving application state transitions.

Most APIs strive for at least level 2 maturity with proper use of HTTP and resources. Level 3 hypermedia-driven systems are more flexible but complex to build.

REST vs SOAP Web Services

REST and SOAP represent two different architectural approaches for building web services:

Architectural style Resource-based Method-based
Protocol HTTP HTTP, SMTP, TCP, etc
Message format JSON, XML, HTML XML
Caching Easy to cache Not cacheable
Security SSL/TLS, OAuth WS-Security

In summary, REST emphasizes simplicity, scalability and loose coupling while SOAP focuses more on standardized schemas and stringent security.

Example REST APIs

Some examples of popular REST APIs include:

  • Twitter API – Manage tweets, followers, search, etc.
  • GitHub API – Programmatically access GitHub resources and functions.
  • Stripe API – Integrate payments into an application.
  • Slack API – Build bots and integrate with Slack teams.
  • Twilio API – Add messaging, voice and video to apps.


REST is an architectural style that leverages principles like statelessness and uniform interfaces for building highly scalable, flexible and loosely coupled distributed systems. It makes efficient use of modern web protocols and is now the predominant approach for building web services and APIs. Understanding RESTful principles and constraints is essential for modern web development.