ForHosting KIT · Developer Utilities

Batch throughput calculator

The batch throughput calculator turns a batch size and processing interval into an effective item rate.

● BetaFree · in your browser
Use it from WebAPIEmailTelegramApp soon

It reports items per second, minute, and hour, then optionally compares that capacity with a target. When you provide a target rate, it calculates the minimum whole-item batch size needed at the current processing time and the longest interval your current batch can tolerate. This makes capacity assumptions explicit before you tune workers, queue consumers, imports, inference jobs, or scheduled bulk operations.

Translate batch behavior into a comparable rate

Batch systems are often described with two numbers that are difficult to compare directly: how many items a run handles and how long that run takes. The calculator divides batch size by batch time to produce effective throughput in items per second, then expands the same rate into items per minute and hour. For example, a worker that completes 500 items every 20 seconds sustains 25 items per second, assuming it can begin the next batch without additional delay. Use elapsed launch-to-launch time when setup, polling, cooldown, or queue delay belongs in your real operating cycle. Use measured processing time only when those delays are handled elsewhere and you intentionally want compute-stage capacity. The result is an average rate, not a claim that individual items finish evenly throughout the interval. A batch may release all of its results at once while still having the reported long-run throughput. Keeping that distinction clear helps compare batch consumers with streaming workers without confusing delivery latency and processing capacity.

Plan a batch size for a target throughput

Add a target rate in items per second when you need to know whether the current configuration can keep up with arrivals or a service objective. The calculator multiplies the target by the current batch time and rounds upward to the next whole item. Rounding up is essential because a fractional item cannot be added to a batch, and rounding down would quietly produce less capacity than requested. The result called required batch size therefore represents the smallest integer batch that reaches or exceeds the target while processing time stays unchanged. The accompanying resulting rate shows the small amount of excess capacity that integer rounding may introduce. This scenario assumes that increasing the batch size does not increase processing time. That can be a useful first estimate, but real databases, APIs, memory limits, and parallel workers may scale nonlinearly. After choosing a candidate, benchmark it with representative payloads and feed the measured interval back into the calculator. Repeating that loop replaces an optimistic sizing assumption with evidence from the actual system.

Find the interval allowed by an existing batch

Sometimes batch size cannot change because an upstream API, transaction limit, memory budget, or message broker sets a hard ceiling. In that case, the target analysis also calculates the maximum batch time permitted at the current size. It divides the current number of items by the target items per second. A 600-item batch serving a 40-item-per-second target, for example, must complete on a launch-to-launch interval of 15 seconds or less. Compare that threshold with measured high-percentile timing rather than only the fastest or average run. If ordinary variation pushes batches beyond the threshold, the nominal configuration may meet the target while the production queue still grows. The rate ratio provides another compact planning signal: values above one indicate capacity greater than the target, one means exact equality, and values below one show a deficit. The model assumes batches run sequentially as one effective lane. For several identical concurrent workers, calculate the observed combined batch size over a shared interval, or calculate each lane separately and add their sustainable rates only when work distribution is balanced.

Size a queue consumer

Convert consumer batch size and launch interval into a rate, then check whether it exceeds the incoming message rate.

Plan bulk API calls

Find the minimum records per request or maximum request interval needed to maintain a required synchronization speed.

Evaluate data pipeline capacity

Compare measured import batches with a target and identify whether batch size or processing time must improve.

What formula calculates batch throughput?

Effective throughput equals batch size divided by batch time in seconds. The calculator also converts that rate to per-minute and per-hour values.

What should batch time include?

Use launch-to-launch elapsed time for end-to-end capacity. Use processing time alone only when setup and waiting delays are deliberately outside your model.

How is the required batch size calculated?

The target items per second is multiplied by batch time, then rounded up to a whole item so the planned batch does not fall below the target.

Does this account for parallel workers?

Not automatically. Represent the workers as one combined batch over a shared interval, or calculate each worker lane and add rates when load is balanced.

Why might measured production throughput be lower?

Queue delay, retries, setup work, contention, nonlinear batch scaling, and uneven load can reduce observed throughput. Use representative high-percentile timing for safer planning.

What does the API request cost?

Each API request costs $0.002. The calculator can also run free in the browser.

Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.

POSThttps://api.kit.forhosting.com/dev/batch-throughput

Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.

curl -X POST https://api.kit.forhosting.com/dev/batch-throughput \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"batch_size":500,"batch_time_seconds":20}'
{
  "batch_size": 500,
  "batch_time_seconds": 20
}
{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "dev.batch_throughput",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

HTTPCodeMeaning
401unauthorizedMissing or invalid API key.
402insufficient_balanceYour balance doesn't cover the task price.
404unknown_typeThat task type doesn't exist.
429rate_limitedToo many requests. Use the webhook instead of polling.

Read the full KIT documentation →