ForHosting KIT · Developer Utilities

RAID capacity calculator

See how much space a RAID array really leaves you and how many disks it can lose: four 1000 GB disks in RAID 5 give 3000 GB usable, 75% efficiency and survive one failure. Covers RAID 0, 1, 5, 6 and 10. Free in your browser.

Free
Runs in your browser
No sign-up
Your data stays on your device

Run — free How it works & API

Use it from WebAPIEmailTelegramApp soon

Worked example

If you enter

Raid level: 5 GB
Disk count: 4
Disk size: 1,000

You get

Raid name: RAID 5 GB
Min disks: 3
Raw capacity: 4,000
Usable capacity: 3,000

Planning a storage array starts with a simple question: how much usable space do you keep after striping, mirroring, or parity, and how many disks can fail before data is lost. This RAID capacity calculator accepts a RAID level (0, 1, 5, 6, or 10), the number of identical member disks, and each disk’s size, then returns raw capacity, usable capacity, overhead reserved for mirrors or parity, storage efficiency as a percentage, and fault tolerance as the count of disks the layout can lose. Formulas match the classic textbook models used in server builds, homelab spreadsheets, and capacity planning docs—RAID 0 uses all disks with zero redundancy, RAID 1 keeps one disk of usable space with N−1 fault tolerance, RAID 5 and 6 trade one or two disks for single or dual parity, and RAID 10 halves capacity for striped mirrors.

What RAID capacity, overhead, and fault tolerance mean

Raw capacity is simply disk count times disk size: every byte on every spindle or SSD before any RAID layout. Usable capacity is what a volume manager or hardware controller presents after reserving space for mirrors or parity. Overhead is the difference—capacity you pay for but do not store unique user data on—whether that is a full mirror set in RAID 1, one disk equivalent of distributed parity in RAID 5, two disks of dual parity in RAID 6, or half the array in RAID 10.

Efficiency is usable divided by raw, expressed as a percentage, so a four-disk RAID 5 at equal sizes is seventy-five percent efficient and a four-disk RAID 10 is fifty percent. Fault tolerance is the number of concurrent member failures the layout can survive while still reconstructing data: zero for RAID 0, N minus one for an N-way RAID 1 mirror, one for RAID 5, two for RAID 6, and up to N over two for RAID 10 when failures fall one per mirrored pair.

These figures assume identical disk sizes; real controllers often size to the smallest member, so feed the effective per-disk size you will actually use. The calculator does not model hot spares, compression, thin provisioning, file-system overhead, or vendor-specific RAID-Z variants—it answers the classic capacity and resilience numbers planners put in a BOM or change request. Choose the level for the failure model you accept, then read usable capacity and overhead together so cost per usable terabyte is honest.

Where these capacity figures pay off

System builders and managed-service teams need a deterministic oracle when quoting arrays so sales sheets, Ansible inventory notes, and customer portals agree on usable terabytes for the same disk SKU and level. Procurement workflows batch-evaluate RAID 5 versus RAID 6 versus RAID 10 for a fixed disk count without reopening a spreadsheet for every SKU change. Training labs and certification prep can check student answers for overhead and fault tolerance without standing up a full storage simulator.

Failed validation does not consume balance. Reproducible usable capacity and fault tolerance numbers keep BOMs, runbooks, and edge workers aligned without hosting custom RAID math of your own.

What you can do with it

Server and SAN capacity quotes

Turn disk count, size, and RAID level into usable capacity, overhead, and efficiency for BOMs and customer quotes.

Homelab and build planning

Compare RAID 5, 6, and 10 for the same drives before buying: fault tolerance and usable space side by side.

Automation and inventory checks

Validate declared array capacity in CMDB or Ansible data against the classic formulas for levels 0, 1, 5, 6, and 10.

FAQ

What RAID levels are supported?

RAID 0 (stripe), RAID 1 (N-way mirror), RAID 5 (single parity), RAID 6 (dual parity), and RAID 10 (striped mirrors). Other levels such as RAID 50 or ZFS RAID-Z are out of scope.

Why must RAID 10 have an even disk count?

RAID 10 is built from mirrored pairs striped together.

Does the unit field convert GB to TB?

No. unit is an optional display label (default GB) echoed on capacity fields. Convert sizes yourself before calling if you need a different unit.

How many disks can fail in each RAID level?

None in RAID 0, all but one in RAID 1, one in RAID 5 and two in RAID 6. RAID 10 survives up to half its disks, but only when each failure falls in a different mirrored pair.

What if my disks are not all the same size?

The figures assume identical disks, and real controllers usually size every member to the smallest one. Enter that smallest size, the space each disk will actually contribute, to get honest numbers.

Related tools

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

POSThttps://api.kit.forhosting.com/dev/raid-capacity

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/raid-capacity \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"raid_level":"5","disk_count":4,"disk_size":1000}'

const res = await fetch("https://api.kit.forhosting.com/dev/raid-capacity", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "raid_level": "5",
    "disk_count": 4,
    "disk_size": 1000
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/dev/raid-capacity",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "raid_level": "5",
    "disk_count": 4,
    "disk_size": 1000
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/raid-capacity", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"raid_level":"5","disk_count":4,"disk_size":1000}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"raid_level":"5","disk_count":4,"disk_size":1000}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/raid-capacity", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "raid_level": "5",
  "disk_count": 4,
  "disk_size": 1000
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "dev.raid_capacity",
  "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

Per request$0.002

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.

Technical notes

The same pure arithmetic powers the free browser path and the API, so quotes, runbooks, and automation never disagree on a four-disk RAID 5 or a six-disk RAID 10. Invalid levels, odd counts for RAID 10, or too few members fail with invalid_input instead of inventing capacity.

Input contract, formulas by level, and error behaviour

Minimum members: two for RAID 0 and RAID 1, three for RAID 5, four for RAID 6, and four with an even count for RAID 10. Formulas with N disks of size S: RAID 0 usable equals N times S and fault tolerance zero; RAID 1 usable equals S with fault tolerance N minus one; RAID 5 usable equals (N minus one) times S with fault tolerance one; RAID 6 usable equals (N minus two) times S with fault tolerance two; RAID 10 usable equals (N over two) times S with fault tolerance N over two. Pin those numbers in tests so capacity quotes stay reproducible across runtimes. POST a JSON body with three required fields: raid_level (0, 1, 5, 6, or 10—numbers or strings such as raid5 and RAID-10 are accepted), disk_count (integer member count), and disk_size (finite capacity per disk in your chosen unit). Optional unit defaults to GB and is echoed only as a label; the API does not convert between GB and TB. On success the body includes raid_level, raid_name, disk_count, disk_size, unit, min_disks, raw_capacity, usable_capacity, overhead_capacity, efficiency_percent, fault_tolerance, formula, and notes. Missing fields, non-positive disk_size, non-integer disk_count, unsupported levels, too few disks, or an odd RAID 10 count fail with invalid_input and are not billed. Example: raid_level five, four disks of one thousand GB yields raw four thousand, usable three thousand, overhead one thousand, efficiency seventy-five percent, and fault tolerance one.

Where a RAID capacity API earns its keep

Keep requests small, treat unit as a label, and remember that rebuild time, URE risk, and controller limits are outside this endpoint—pair the capacity result with your own operational guidance.

Technical questions

How do I calculate usable RAID capacity?

Send raid_level (0, 1, 5, 6, or 10), disk_count, and disk_size. The API returns usable_capacity, overhead_capacity, efficiency_percent, and fault_tolerance using standard identical-disk formulas.

What does the RAID capacity calculator cost?

The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.

Read the full KIT documentation →

Run — free