Skip to main content

RESTful APIs (Live Playground)

REST Principles​

REST (Representational State Transfer) is an architectural style that defines a set of constraints to be used when designing web services. It is particularly well-suited for designing APIs, as it helps to create scalable, maintainable, and efficient systems. In this tutorial, we will discuss the principles of REST and how they apply to API design.

Stateless​

Each API request should contain all the information needed for the server to process the request. No session state is stored on the server-side between requests. This constraint allows for greater scalability and simplicity when designing the API.

Client-Server​

The client and server are separate entities that communicate over a network. The client is responsible for the user interface, while the server handles data storage and processing. This separation of concerns allows for flexibility and maintainability.

Cacheable​

API responses can be marked as cacheable or non-cacheable. Cacheable responses can be stored by the client, reducing the need for repeated requests to the server and improving performance.

Layered System​

A RESTful architecture can be composed of multiple layers, each with a specific responsibility. This allows for separation of concerns, making the system more modular and maintainable.

Code on Demand (optional)​

In some cases, the server can provide executable code to the client. This principle is optional and less common in modern API design.

Uniform Interface​

A consistent interface across all endpoints of the API makes it easier to understand and use. Some key components of a uniform interface include:

  • Resource identification: Each resource should be uniquely identifiable using a URL.
  • Resource manipulation: Clients should be able to manipulate resources using standard HTTP methods (GET, POST, PUT, DELETE, etc.).
  • Self-descriptive messages: Each message should include enough information for the client to understand how to process it.
  • Hypermedia as the engine of application state (HATEOAS): Responses should include links to related resources, allowing the client to navigate the API.

CRUD Operations in RESTful APIs​

CRUD (Create, Read, Update, and Delete) operations are the basic actions performed on a database or data storage system. In RESTful APIs, these operations are mapped to the standard HTTP methods.

Create (POST)​

To create a new resource, the client sends an HTTP POST request to the server, including the data to be stored as the resource. The server processes the request and, upon successful creation, returns a response with a status code of 201 (Created).

Example:

fetch('https://jsonplaceholder.typicode.com/posts', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ key: 'value' }),
})
  .then(response => {
    console.log(response);
    return response.json();
  })
  .then(data => console.log(data));
Live Playground, Try it Yourself

Read (GET)​

Reading a resource involves retrieving its current state. The client sends an HTTP GET request to the server, which returns the resource data in the response. A successful GET request typically has a status code of 200 (OK).

Example:

fetch('https://jsonplaceholder.typicode.com/posts/1')
  .then(response => {
    console.log(response);
    return response.json();
  })
  .then(data => console.log(data));
Live Playground, Try it Yourself

Update (PUT or PATCH)​

Updating a resource involves modifying its state. The client sends an HTTP PUT or PATCH request to the server, along with the updated data. A PUT request replaces the entire resource, while a PATCH request modifies only the specified fields. Upon successful update, the server returns a status code of 200 (OK) or 204 (No Content).

Example:

fetch('https://jsonplaceholder.typicode.com/posts/1', {
  method: 'PUT',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ key: 'updatedValue' }),
})
  .then(response => {
    console.log(response);
    return response.json();
  })
  .then(data => console.log(data));
Live Playground, Try it Yourself

Delete (DELETE)​

Deleting a resource involves removing it from the data storage system. The client sends an HTTP DELETE request to the server, which processes the request and returns a status code of 200 (OK) or 204 (No Content) upon successful deletion.

Example:

fetch('https://jsonplaceholder.typicode.com/posts/1', {
  method: 'DELETE',
})
  .then(response => {
    console.log(response);
    return response.json();
  })
  .then(data => console.log(data));
Live Playground, Try it Yourself

Conclusion​

Understanding CRUD operations and their corresponding HTTP methods is crucial for working with RESTful APIs. By using standard HTTP methods, developers can create consistent and easy-to-understand APIs that facilitate data manipulation.