Servers needed for load calculator
The servers needed for load calculator turns a traffic forecast into a practical horizontal scaling target.
Run — free
Enter the peak request rate you must serve, the measured request capacity of one server, and the percentage of capacity you want to keep unused as safety headroom. The calculator reduces each server's usable capacity by that margin, divides the target load by the result, and rounds upward so the plan never depends on a fraction of a machine. It also reports provisioned capacity, usable capacity, remaining usable capacity, and expected utilization so reviewers can see exactly what the server count means.
Start with a load target and measured server capacity
A useful sizing result begins with compatible measurements. Enter the target request rate as the highest sustained rate the deployment is expected to handle, not a daily average that hides busy periods. Enter per-server capacity from a representative load test using the same application build, instance shape, request mix, dependencies, and latency objective planned for production. Both values use requests per second, so no time conversion is needed. If a server can technically accept more traffic only by violating the service-level objective, that higher number is not usable capacity and should not be entered. The calculator accepts a zero target, which produces zero required servers and is useful when documenting an inactive environment, but server capacity must always be positive. Treat the output as a capacity-planning baseline rather than a substitute for testing. Database limits, connection pools, queues, shared caches, rate-limited upstream services, regional traffic imbalance, and slow requests can all become bottlenecks before application servers exhaust their nominal throughput. Re-run the calculation whenever those workload assumptions or benchmarks change.
Use headroom to keep the fleet away from its ceiling
Safety headroom is the percentage of every server's measured capacity deliberately held in reserve. With 25 percent headroom, a server benchmarked at 1,200 requests per second contributes 900 requests per second to the sizing calculation. Reserving capacity gives autoscaling time to start instances, absorbs forecast error and short bursts, and reduces the chance that latency rises sharply as utilization approaches saturation. The correct margin depends on operational behavior rather than a universal rule. A stable internal batch service with fast instance startup may tolerate a smaller reserve, while a public API with bursty traffic, slow warm-up, or strict latency targets may need more. Enter the margin as a percentage from zero up to, but not including, 100. The calculator divides target traffic by the reduced usable capacity and always rounds the result upward. Because rounding is performed after the headroom adjustment, the reported integer fleet can carry at least the target rate under the stated assumptions. Compare several margins during planning to make the resilience and cost tradeoff visible to stakeholders.
Interpret the result and turn it into a provisioning decision
The primary result is servers needed: the minimum whole number of identical servers whose headroom-adjusted capacity reaches the target. Usable capacity per server shows the benchmark after the reserve is removed. Provisioned capacity shows the fleet's full nominal throughput, while usable provisioned capacity shows how much of that throughput the plan permits workloads to consume. Spare usable capacity is the difference between the permitted fleet capacity and the target rate; it appears because the final server count is rounded upward. Utilization percent compares target traffic with full nominal fleet capacity, so it normally sits below the percentage allowed after headroom. Use these fields to document the assumptions behind an autoscaling minimum, a fixed fleet, or an infrastructure budget. Then test the resulting topology, including load distribution and failure scenarios. For high availability, placement constraints or tolerance of instance loss may require more servers than pure throughput sizing indicates. This calculator does not add redundancy for zones, replicas, maintenance, or failover automatically; apply those architectural requirements after establishing the load-based minimum, and revisit the calculation when server types or application performance change.
What you can do with it
Set an autoscaling baseline
Convert forecast peak traffic and benchmark throughput into a defensible minimum instance count with explicit capacity reserve.
Compare instance types
Run the same target against measured capacities for several server shapes to compare fleet sizes before provisioning.
Document a capacity review
Record the target, benchmark, headroom, utilization, and spare usable throughput behind a scaling decision.
FAQ
How is the required server count calculated?
Usable capacity per server equals per-server capacity multiplied by one minus the headroom percentage. The target request rate is divided by that usable capacity, then rounded upward to a whole server.
What should I use for per-server capacity?
Use sustained throughput from a representative load test that still meets your latency and error-rate objectives. Keep the application, instance type, request mix, and dependencies close to production.
Does headroom mean extra servers?
Headroom reduces the capacity credited to each server, which can increase the rounded fleet size. It keeps part of nominal capacity available for bursts, startup delays, and forecast error.
Does the result include high-availability redundancy?
No. It calculates the throughput-based minimum only. Add any extra instances required for zone failure, maintenance, replicas, quorum, placement rules, or other resilience policies.
What does the API request cost?
Each API calculation costs $0.002. The same deterministic calculator can also run free in the browser on this page.
For developers — API access
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.
API endpoint
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.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/dev/servers-needed \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"target_request_rate":10000,"per_server_capacity":1200,"headroom_percent":25}'const res = await fetch("https://api.kit.forhosting.com/dev/servers-needed", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"target_request_rate": 10000,
"per_server_capacity": 1200,
"headroom_percent": 25
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/dev/servers-needed",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"target_request_rate": 10000,
"per_server_capacity": 1200,
"headroom_percent": 25
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/servers-needed", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"target_request_rate":10000,"per_server_capacity":1200,"headroom_percent":25}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"target_request_rate":10000,"per_server_capacity":1200,"headroom_percent":25}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/servers-needed", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"target_request_rate": 10000,
"per_server_capacity": 1200,
"headroom_percent": 25
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev.servers_needed",
"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.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |