Options for throttling requests

[PopGoesTheWza]

What problem are you trying to solve?

I want to define a got instance where requests are throttled (i.e. 30 requests per minutes). Currently I can achieve this using p-throttle to wrap each simple got requests where they occur, and I haven't find a clean way to throttle paginate.

Describe the feature

I think it would be nice if got had throttling options "à la" p-throttle so that it is define at the got instance level.

Maybe there is already a way to achieve this, but I failed at finding it through the docs, issues and discussions.

Checklist

• I have read the documentation and made sure this feature doesn't already exist.

[szmarczak]

This can be implemented via an agent.

[paya-cz]

I am also looking into throttling requests with Got, but I haven't found a clear way yet.

How can I do this with an agent if I am already using agents from agentkeepalive for http/https and http2-wrapper for http2?

[paya-cz]

I need to throttle requests and at the same time assign priorities to the throttled requests. Queued requests need to be unthrottled according to their priority. It seems this cannot be easily done with an agent?

beforeRequest hook looks like a better option and is straightforward to use, or am I missing something?

[PopGoesTheWza]

Not to doubt the validity of your answer, but it seems a bit steep.
Browsing nodejs agent documentation, searching SO and more generally Google, I do not see how implement such agent. Maybe I missed the obvious but I guess it is no simple task.
Maybe I should stick with p-throttle and avoid paginate for now.

[szmarczak]

You can pass a handler function and add locks there.

[jeanbmar]

It's not exactly the same as throttling, but I had to ensure a minimal delay between 2 requests, so I made this debouncing plugin: https://www.npmjs.com/package/got-plugin-debounce

[sindresorhus]

Got doesn't have built-in throttling, but p-queue is the cleanest solution for this. You can create a wrapper that automatically throttles all requests:

import PQueue from 'p-queue';
import got from 'got';

const queue = new PQueue({
	intervalCap: 30,      // Max 30 requests
	interval: 60000,      // Per 60 seconds
	concurrency: 10       // Optional: max concurrent requests
});

// Create a throttled Got instance
const throttledGot = got.extend({
	handlers: [
		(options, next) => {
			return queue.add(() => next(options));
		}
	]
});

// Use it like normal Got
await throttledGot('https://api.example.com/data').json();

// Also works with pagination
for await (const item of throttledGot.paginate('https://api.example.com/items')) {
	console.log(item);
}

This approach wraps all requests automatically, so you don't need to remember to throttle individual calls. The handlers option intercepts every request and adds it to the queue before execution.

If you prefer a simpler per-request delay, you can use the beforeRequest hook with a simple delay mechanisim, but p-queue gives you much better control over rate limiting.