How to Integrate REST APIs in ReactJS Applications

APIs (Application Programming Interfaces) play a crucial role in modern web development. They allow applications to communicate with external services and fetch or send data. If you’re building a ReactJS application, integrating REST APIs is essential for displaying dynamic data, handling user authentication, and performing various other tasks.

In this guide, we’ll walk you through how to integrate REST APIs in ReactJS step by step. Whether you’re a beginner or an experienced developer, this article will provide you with best practices and useful tips to enhance your React project.

What is a REST API?

A REST API (Representational State Transfer API) is a web service that allows clients (like a React app) to interact with a server. It follows HTTP methods such as:

• GET – Retrieve data

• POST – Send new data

• PUT/PATCH – Update existing data

• DELETE – Remove data

For example, if you need to fetch user details from a backend, you might call an API like:

https://api.example.com/users

which returns a JSON response:

{
“id”: 1,
“name”: “John Doe”,
“email”: “john@example.com”
}

Now, let’s see how to use this API in a ReactJS application.

1. Setting Up a React Project

Before integrating APIs, make sure you have a React project set up. If you don’t have one yet, you can create it using:

npx create-react-app my-app
cd my-app
npm start

This will create a new React app and start the development server.

2. Fetching Data Using Fetch API

The Fetch API is a built-in JavaScript function for making HTTP requests. You can use it inside the useEffect hook to fetch data when a component loads.

Example: Fetch Users List

import React, { useState, useEffect } from “react”;

const UsersList = () => {
const [users, setUsers] = useState([]);

useEffect(() => {
fetch(“https://jsonplaceholder.typicode.com/users”)
.then((response) => response.json())
.then((data) => setUsers(data))
.catch((error) => console.error(“Error fetching data:”, error));
}, []);

return (
<div>
<h2>User List</h2>
<ul>
{users.map((user) => (
<li key={user.id}>{user.name} – {user.email}</li>
))}
</ul>
</div>
);
};

export default UsersList;

How It Works:

• The useEffect hook runs once when the component mounts.

• fetch() sends a GET request to the API.

• The response is converted to JSON and stored in users state.

• The user list is displayed in the UI.

3. Using Axios for API Calls

Although Fetch API works well, Axios is a popular alternative that offers better error handling and simpler syntax.

Install Axios:

npm install axios

Example: Fetch Users List with Axios

import React, { useState, useEffect } from “react”;
import axios from “axios”;

const UsersList = () => {
const [users, setUsers] = useState([]);

useEffect(() => {
axios.get(“https://jsonplaceholder.typicode.com/users”)
.then((response) => setUsers(response.data))
.catch((error) => console.error(“Error fetching data:”, error));
}, []);

return (
<div>
<h2>User List</h2>
<ul>
{users.map((user) => (
<li key={user.id}>{user.name} – {user.email}</li>
))}
</ul>
</div>
);
};

export default UsersList;

Why Use Axios?

• Automatically converts response to JSON
• Supports request timeout
• Better error handling
• Supports request cancellation

4. Handling POST Requests (Sending Data to API)

If you need to send user input to an API, you’ll use a POST request.

Example: Add New User

import React, { useState } from “react”;
import axios from “axios”;

const AddUser = () => {
const [name, setName] = useState(“”);
const [email, setEmail] = useState(“”);

const handleSubmit = async (e) => {
e.preventDefault();

const newUser = { name, email };

try {
const response = await axios.post(“https://jsonplaceholder.typicode.com/users”, newUser);
console.log(“User added:”, response.data);
} catch (error) {
console.error(“Error adding user:”, error);
}
};

return (
<div>
<h2>Add New User</h2>
<form onSubmit={handleSubmit}>
<input
type=”text”
placeholder=”Name”
value={name}
onChange={(e) => setName(e.target.value)}
required
/>
<input
type=”email”
placeholder=”Email”
value={email}
onChange={(e) => setEmail(e.target.value)}
required
/>
<button type=”submit”>Add User</button>
</form>
</div>
);
};

export default AddUser;

How It Works:

• User inputs are stored in state (name and email).

• On form submission, an API call is made with axios.post().

• The new user is sent to the API and logged in the console.

5. Handling PUT/PATCH Requests (Updating Data)

To update existing data, use PUT (for full updates) or PATCH (for partial updates).

Example: Update User Email

axios.patch(“https://jsonplaceholder.typicode.com/users/1”, { email: “newemail@example.com” })
.then(response => console.log(“User updated:”, response.data))
.catch(error => console.error(“Error updating user:”, error));

6. Handling DELETE Requests (Removing Data)

To delete data from an API, use a DELETE request.

Example: Delete User

axios.delete(“https://jsonplaceholder.typicode.com/users/1”)
.then(() => console.log(“User deleted”))
.catch(error => console.error(“Error deleting user:”, error));

This will remove the user with ID 1 from the database.

7. Best Practices for API Integration in ReactJS

To ensure smooth API integration, follow these best practices:

• Use Environment Variables – Store API URLs in .env files to keep them secure.
• Handle Errors Properly – Always use .catch() for error handling.
• Use Loading States – Show a loading spinner when fetching data.
• Cache API Responses – Use React Query or local storage for frequently accessed data.
• ReactJS Development Company – If working on a large project, consider hiring experts for scalable API integration.

Final Thoughts

Integrating REST APIs in ReactJS is essential for building dynamic web applications. By using Fetch API or Axios, you can easily fetch, send, update, and delete data from a server. Following best practices like error handling, caching, and using environment variables will improve performance and security.

Now that you know how to work with REST APIs in React, what will you build next? Let us know in the comments!