Hardness scale converter
A steel part at 40 HRC reads about 371.4 Brinell or 392 Vickers. Convert between Rockwell C, B and A, Brinell, Vickers and Knoop through one steel reference table, with every interpolation step written out for a lab notebook or certificate. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Value
- 40
- From
- hrc
- To
- hb
- Result
- 371.4 hb
- Converted
- 371.4
- Value hv
- 392
- Scale from
- Rockwell C (HRC)
A hardness scale converter turns a metal hardness reading from one common laboratory scale into another without flipping paper charts or rebuilding spreadsheet tables. Enter a non-negative hardness number plus a source scale and a target scale among Rockwell C, Rockwell B, Rockwell A, Brinell, Vickers and Knoop; the tool returns the converted reading, the approximate Vickers HV pivot used as the intermediate, a multi-scale snapshot, human-readable scale names, and step-by-step interpolation lines you can paste into a lab notebook or quality report. Heat-treat shops, incoming inspection, materials students, and procurement teams that receive mixed Rockwell and Brinell certificates all need that same deterministic path.
What hardness scales mean and how conversion works
Metal hardness is reported on several empirical scales that measure resistance to permanent indentation under different indenters, loads and dwell times. Rockwell C uses a diamond cone at a high major load and is common for hardened steels; Rockwell B uses a steel ball and suits softer alloys; Rockwell A is a lighter diamond-cone scale often used for carbides and thin case layers. Brinell presses a hard ball into the surface and reports a hardness number from the indentation diameter.
Vickers and Knoop use diamond pyramid indenters and are popular for microhardness and for reporting a continuous number across a wide range. These scales are not SI units linked by exact dimensional factors: conversion between them is approximate and material-dependent. This capability implements a fixed ASTM E140-style reference table for unalloyed and low-alloy steel, with Vickers HV as the pivot.
The solver interpolates piecewise linearly from the source scale to HV, then from HV to the target scale, using only the published table points—no network, no random seeds, and no wall-clock dependence. Values must stay inside the envelope covered by the table for that scale—for example Rockwell C roughly twenty through seventy, Rockwell B roughly fifty-six through ninety-eight—so clients never invent a hardness that the chart never defined.
Practical tips, limits, and when to use this landing
Prefer sending bare numbers for value when you control the client; string numbers are accepted only when they match a strict finite numeric pattern without unit suffixes or thousand separators. Treat results as approximate steel equivalents, not as a substitute for the original test method on the same coupon: different materials, work hardening, indentation size effect and surface condition all shift real readings.
Round-trip checks are straightforward: convert forty HRC to Brinell and Brinell back toward Rockwell C and confirm you recover a value near the original within interpolation tolerance of the fixed table. When teaching materials lab courses, pair classic examples such as forty HRC to roughly three hundred seventy-nine HB under this table, two hundred HB toward Rockwell B near the mid-nineties, and four hundred HV to Rockwell C near forty point eight. Stay inside each scale’s published segment so interpolation never extrapolates past the last table node.
This landing targets people searching for a hardness scale converter, Rockwell to Brinell, HRC to HV, Brinell to Vickers, or Knoop hardness conversion online; it is not a full multi-material ASTM calculator with separate stainless or nonferrous tables, not a hardness tester simulator, and not a tensile-strength estimator from hardness. Prefer this capability when you need a fast, free, deterministic Rockwell–Brinell–Vickers–Knoop bridge for steel-range numbers; if you require certified multi-alloy tables or live instrument drivers, use a laboratory standard package instead.
What you can do with it
Incoming inspection and mixed certificates
QA teams convert supplier Rockwell readings to Brinell or Vickers to match drawing callouts and internal acceptance limits without manual chart lookup.
Heat-treat traveler and shop floor display
Furnace and temper stations show HRC process targets beside HB or HV customer requirements from one deterministic conversion path.
FAQ
Are the conversions exact?
They are deterministic interpolations on a fixed ASTM E140-style steel table with a Vickers HV pivot. Hardness conversion is always approximate and material-dependent; results are not a substitute for testing on the same specimen.
Why was my Rockwell C value rejected?
HRC is only defined on the table envelope roughly 20–70 for this steel chart. Soft or extreme values belong on HRB, HV or another scale covered by the table.
Is the hardness scale converter free?
The browser tool is free and runs locally.
What is 40 HRC in Brinell?
About 371.4 HB on the steel reference table. The same reading also shows as 392 HV, 70.6 HRA and 405.6 HK, so you can fill several columns of a certificate at once.
Can I use it for metals other than steel?
Only as a rough guide. The table covers unalloyed and low-alloy steel, and other materials, work hardening, surface condition and indentation size all shift real readings. For anything critical, test the part on the scale you need.
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
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/conv/hardness \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"value":40,"from":"hrc","to":"hb"}'const res = await fetch("https://api.kit.forhosting.com/conv/hardness", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"value": 40,
"from": "hrc",
"to": "hb"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/conv/hardness",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"value": 40,
"from": "hrc",
"to": "hb"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/conv/hardness", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"value":40,"from":"hrc","to":"hb"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"value":40,"from":"hrc","to":"hb"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/conv/hardness", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"value": 40,
"from": "hrc",
"to": "hb"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "conv.hardness",
"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.
Limits
max_abs | 1000000000000 |
hv_min | 80 |
hv_max | 1000 |
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
Unknown unit names fail with a clear invalid_input error instead of silent wrong factors, and values outside the published steel table envelope are rejected the same way.
What hardness scales mean and how conversion works
Common aliases are accepted case-insensitively: hrc, rockwell c and rc for Rockwell C; hrb and rockwell b for Rockwell B; hra and rockwell a for Rockwell A; hb, bhn, hbw and brinell for Brinell; hv, vickers and dph for Vickers; hk and knoop for Knoop. If the name is not on that list the solver rejects the request with invalid_input naming the bad field and listing supported units.
How to call the API and read the response
Value must be a finite non-negative number or a strict numeric string within the published absolute limit of one trillion. Wire this into inspection forms, heat-treat travelers, LIMS adapters, mobile clients or batch jobs that already hold one hardness reading and only need a second representation for customer certificates, drawing callouts or regulatory comparison without shipping conversion charts in every app binary. Send a JSON body with three required fields: value (aliases amount, hardness, h, n and reading), from (aliases from_unit, unit_from, source and from_scale), and to (aliases to_unit, unit_to, target and to_scale). From and to must resolve to supported scale names after alias normalization. On success the response echoes the rounded input value, canonical from and to labels, result and converted set to the same rounded target magnitude, value_hv as the Vickers pivot, unit as the target label, scale_from and scale_to as English scale names, formula as a short description of the table interpolation path, message as an English summary, as as a multi-scale snapshot of hrc, hrb, hra, hb, hv and hk (null where the pivot falls outside that scale’s table segment), steps as ordered substitution lines, and supported_units as the six canonical identifiers. Failed validation—missing fields, non-finite or negative numbers, values outside a scale’s supported range, values outside absolute limits, or an unknown unit name—returns invalid_input and is never charged. Pricing is a flat $0.002 per successful request with unit item and zero marginal unit price.
Practical tips, limits, and when to use this landing
Failed tasks that return invalid_input do not consume prepaid balance, which keeps exploratory scripts cheap when clients deliberately probe unknown unit names or out-of-range Rockwell numbers.
Integration use cases
Lab homework and coding kata expected values
Students and developers generate deterministic Rockwell↔Brinell↔Vickers cases plus deliberate unknown-unit rejections for worksheets and unit tests.
Technical questions
Which hardness scales are supported?
Rockwell C (hrc), Rockwell B (hrb), Rockwell A (hra), Brinell (hb), Vickers (hv) and Knoop (hk), including common aliases such as brinell, vickers, knoop and rockwell c.
What happens with an unknown unit name?
The API returns invalid_input, names the bad field, and lists supported units. Failed validation is never charged.