Skip to content
TheChatArchiveThe Chat Archive
Claudeclaude-sonnet-4-20250514· AnthropicHugging Face LMArena Human Preference 140K

Using axios and React, how can I make code which makes multiple serial requests. The…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with DeepSeekdeepseek-r1-0528’s answer.
  1. User

    Using axios and React, how can I make code which makes multiple serial requests. The first request should happen, then based on the response, we make the next request and so on.

  2. Claude Assistant

    You can handle serial requests in React using async/await with axios. Here are a few approaches:

    Basic Serial Requests with async/await

    import { useState } from 'react';
    import axios from 'axios';
    
    function SerialRequests() {
      const [loading, setLoading] = useState(false);
      const [results, setResults] = useState([]);
    
      const makeSerialRequests = async () => {
        setLoading(true);
        try {
          // First request
          const firstResponse = await axios.get('/api/first-endpoint');
          
          // Second request based on first response
          const secondResponse = await axios.get(`/api/second-endpoint/${firstResponse.data.id}`);
          
          // Third request based on second response
          const thirdResponse = await axios.post('/api/third-endpoint', {
            data: secondResponse.data.someValue
          });
    
          setResults([firstResponse.data, secondResponse.data, thirdResponse.data]);
        } catch (error) {
          console.error('Request failed:', error);
        } finally {
          setLoading(false);
        }
      };
    
      return (
        <div>
          <button onClick={makeSerialRequests} disabled={loading}>
            {loading ? 'Loading...' : 'Make Serial Requests'}
          </button>
          {/* Display results */}
        </div>
      );
    }
    

    More Flexible Approach with Dynamic Chaining

    import { useState } from 'react';
    import axios from 'axios';
    
    function DynamicSerialRequests() {
      const [loading, setLoading] = useState(false);
      const [allResponses, setAllResponses] = useState([]);
    
      const makeChainedRequests = async () => {
        setLoading(true);
        const responses = [];
        
        try {
          // Start with initial data
          let currentData = { userId: 123 };
          
          // First request
          const userResponse = await axios.get(`/api/users/${currentData.userId}`);
          responses.push(userResponse.data);
          
          // Second request depends on user data
          const ordersResponse = await axios.get(`/api/orders?userId=${userResponse.data.id}`);
          responses.push(ordersResponse.data);
          
          // Third request depends on orders
          if (ordersResponse.data.length > 0) {
            const latestOrderId = ordersResponse.data[0].id;
            const orderDetailsResponse = await axios.get(`/api/orders/${latestOrderId}/details`);
            responses.push(orderDetailsResponse.data);
          }
          
          setAllResponses(responses);
        } catch (error) {
          console.error('Chain failed:', error);
        } finally {
          setLoading(false);
        }
      };
    
      return (
        <div>
          <button onClick={makeChainedRequests} disabled={loading}>
            Start Request Chain
          </button>
        </div>
      );
    }
    

    Using a Custom Hook for Reusability

    import { useState, useCallback } from 'react';
    import axios from 'axios';
    
    // Custom hook for serial requests
    function useSerialRequests() {
      const [loading, setLoading] = useState(false);
      const [error, setError] = useState(null);
    
      const executeChain = useCallback(async (requestChain) => {
        setLoading(true);
        setError(null);
        
        try {
          let previousResponse = null;
          const results = [];
          
          for (const requestConfig of requestChain) {
            const config = typeof requestConfig === 'function' 
              ? requestConfig(previousResponse) 
              : requestConfig;
              
            const response = await axios(config);
            results.push(response.data);
            previousResponse = response.data;
          }
          
          return results;
        } catch (err) {
          setError(err);
          throw err;
        } finally {
          setLoading(false);
        }
      }, []);
    
      return { executeChain, loading, error };
    }
    
    // Usage of the custom hook
    function MyComponent() {
      const { executeChain, loading, error } = useSerialRequests();
      const [data, setData] = useState(null);
    
      const handleSerialRequests = async () => {
        try {
          const results = await executeChain([
            { method: 'get', url: '/api/user/profile' },
            (prevResponse) => ({ 
              method: 'get', 
              url: `/api/user/${prevResponse.id}/preferences` 
            }),
            (prevResponse) => ({ 
              method: 'post', 
              url: '/api/recommendations',
              data: { preferences: prevResponse }
            })
          ]);
          
          setData(results);
        } catch (err) {
          console.error('Failed to complete request chain');
        }
      };
    
      return (
        <div>
          <button onClick={handleSerialRequests} disabled={loading}>
            {loading ? 'Processing...' : 'Start Chain'}
          </button>
          {error && <p>Error: {error.message}</p>}
        </div>
      );
    }
    

    The key points are using async/await to wait for each request to complete before making the next one, and passing data from previous responses to configure subsequent requests. The custom hook approach gives you a reusable pattern for different serial request scenarios.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.