This starts concurency number of workers (I'm using workers as a loose term here; don't @ me). Each one makes as many requests as possible until one of the requests is rate-limited or it runs out of time. It them reports how many of the requests completed successfully inside the given time window.

If you know the rate-limit window (1 minute based on your question), this will find the rate-limit. If you need to discover the window, you would want to intentionally exhaust the limit, then slow down the requests and measure the time until they started going through again. The provided code does not do this.

// call apiCall() a bunch of times, stopping when a apiCall() resolves
// false or when "until" time is reached, whichever comes first. For example
// if your limit is 50 req/min (and you give "until" enough time to
// actuially complete 50+ requests) this will call apiCall() 50 times. Each
// call should return a promise resolving to TRUE, so it will be counted as
// a success. On the 51st call you will presumably hit the limit, the API
// will return an error, apiCall() will detect that, and resolve to false.
// This will cause the worker to stop making requests and return 50.
async function workerThread(apiCall, until) {
    let successfullRequests = 0;
    while(true) {
        const success = await apiCall();
        // only count it if the request was successfull
        // AND finished within the timeframe
        if(success && Date.now() < until) {
            successfullRequests++;
        } else {
            break;
        }
    }
    return successfullRequests;
}

// this just runs a bunch of workerThreads in parallell, since by doing a
// single request at a time, you might not be able to hit the limit
// depending on how slow the API is to return. It returns the sum of each
// workerThread(), AKA the total number of apiCall()s that resolved to TRUE
// across all threads.
async function testLimit(apiCall, concurency, time) {
    const endTime = Date.now() + time;
    
    // launch "concurency" number of requests
    const workers = [];
    while(workers.length < concurency) {
        workers.push(workerThread(apiCall, endTime));
    }
    
    // sum the number of requests that succeded from each worker.
    // this implicitly waits for them to finish.
    let total = 0;
    for(const worker of workers) {
        total += await worker;
    }
    return total;
}

// put in your own code to make a trial API call.
// return true for success or false if you were throttled.
async function yourAPICall() {
    try {
        // this is a really sloppy example API
        // the limit is ROUGHLY 5/min, but because of the sloppy server-side
        // implimentation you might get 4-6.
        const resp = await fetch("https://9072997.com/demos/rate-limit/");
        return resp.ok;
    } catch {
        return false;
    }
}

// this is a demo of how to use the function
(async function() {
    // run 2 requests at a time for 5 seconds
    const limit = await testLimit(yourAPICall, 2, 5*1000);
    console.log("limit is " + limit + " requests in 5 seconds");
})();

Note that this method measures the quota available to itself. If other clients or previous requests have already depleted the quota, it will affect the result.