In this post, we will discuss How to make an API fetch request on the button click Reactjs?. I’m assuming that you are clear about React Js from and about the React Js framework and you are also familiar with creating React Js applications. if you are not clear about these then please read the below post.

we will create a web page with textbox and HTML table list.we are binding the table with the data list returned by API.we want to filter the user list by user city so when we click the search button, we pass one parameter into a fetch API request.

In this post we will cover the following points:

  1. Fetch from external API function on button click.
  2. ReactJS display fetch response onClick of Button.
  3. How do make an api fetch request on button click Reactjs?

react fetch data from api on button click

Step 1 – Create React App

Step 2 – Create components for showing List data

Step 3 – Integrate Rest API and handle button click event


import React, { useState, useEffect } from "react";

const FetchDataOnButton = () => {
const [userList, setusers] = useState(null);
const [searchtxt, setSearch] = useState("")
  useEffect(() => {
  }, []);

const getuesers = (url) => {
      .then((res) => res.json())
        (result) => {         
        (error) => {

const handleValue = e => {

const searchUser = e => {
if (!userList) return <div>No Record Found</div>;
return (
      <h2>Users List Funcational Component </h2>
      <div className="row">
        <div className="col-sm-6">
        onChange={e => handleValue(e)}
        <div className="col-sm-6">
        className='btn btn-primary btnsubmit'

      <table className="table">
            <th>User Id</th>
          { => (
export default FetchDataOnButton;

So on the button is clicked, we are making an HTTP request, Updating the state variables, and rendering the data.

Functional Component:The FetchDataOnButton component is defined as an arrow function.

Two state variables are declared using the useState hook: userList to store the list of users fetched from the API, and searchtxt to store the text input for city search.

The useEffect hook is utilized to perform side effects in the component. It's used here to fetch the list of users from a specified API endpoint ( when the component mounts. The getusers function is called inside the useEffect hook.

Fetch Data Function: This function takes a URL parameter and makes a GET request to the specified URL. Upon receiving a response, it converts the response to JSON format and updates the userList state with the fetched data. If there's an error during the request, it logs the error and sets userList to null.

Input Change HandlerThe handleValue function updates the searchtxt state with the value entered in the input field for city search.

Search User FunctionThe searchUser function is triggered when the search button is clicked. It prevents the default form submission behavior, then calls the getusers function with a modified URL based on the searchtxt state, fetching users filtered by city.

Conditional RenderingIf userList is null, it renders a message saying "No Record Found". This handles cases where data hasn't been fetched yet or if there's an error fetching the data.Otherwise, it renders a table displaying the list of users. Each user's details such as id, name, address, city, and zip code are displayed in separate table cells.

It fetches a list of users from an API based on a city search input. It updates the user interface dynamically based on user interaction with the search input and button.

We will discuss this in the next article, but make a note of the two-component types stateless functional components and stateful class components. Now that we have some understanding of the React components, let’s understand the App component in our Hello World react application
it is a JavaScript file. The class is named App and extends the component class from the React library, it contains a render method that returns some HTML.

You can have thousands of components. Facebook, I believe, has over 30000 components, is more complex, and the application has more a number of components. All right, then let me quickly summarize what we have learned about components