ICC net run rate calculator
Scoring 250 in 50 overs and conceding 200 in 50 gives a net run rate of 1.000: runs per over scored minus runs per over conceded, with overs like 47.3 read as 47 overs and three balls. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Runs scored
- 250
- Overs faced
- 50
- Runs conceded
- 200
- Overs bowled
- 50
- Overs faced actual
- 50
- Overs bowled actual
- 50
- Scoring run rate
- 5
- Conceding run rate
- 4
A cricket team's net run rate, or NRR, is the difference between the runs it scores per over and the runs it concedes per over. Tournament tables, World Cup groups, and league standings use that signed rate to break ties when two sides finish on the same points. Coaches, scorekeepers, fantasy managers, and journalists need the figure from four counting stats: runs scored, overs faced, runs conceded, and overs bowled. This ICC net run rate calculator subtracts conceding run rate from scoring run rate, matching the published identity NRR = (runs scored / overs faced) − (runs conceded / overs bowled). Cricket overs written with a ball digit, such as 47.3, become 47 completed overs plus three balls (three-sixths of an over), so a truncated innings is not treated as 47.3 decimal overs. Any overs value that is zero or negative is rejected because the rate would divide by overs.
What net run rate measures and why overs matter
Net run rate answers a tournament question that a raw run total cannot: how much faster, or slower, did this cricket team score than the sides it bowled against, measured in runs per over? The International Cricket Council packs that idea into one identity: NRR equals runs scored divided by overs faced, minus runs conceded divided by overs bowled. The result is a signed rate, not a percentage and not a count of wickets.
Group tables, World Cup standings, and domestic league ladders print it to three decimal places, so a side that scored 250 in 50 overs and conceded 200 in 50 overs appears as 1.000, and a side that leaked runs in truncated chases can sit below zero even after winning more matches than it lost. A completed fifty-over innings of 300 against 250 conceded in 47.3 overs is a legal positive NRR; a side that was rolled for 80 in 30 overs while conceding 240 in 50 sits deeply negative.
This calculator does not decide whether a team was all out, whether a rain rule revised a target, or which extras the scorers added. It applies only the published four-number identity to the totals you already have. Zero runs scored with positive overs faced is a legal scoring rate of 0.000, not missing data.
A season or a group stage with thousands of runs uses the same identity as a single match.
What to enter and how overs are counted
Cricket scorebooks write a tenth digit of 1 through 5 for one to five balls, so 47.3 means 47 overs plus three balls (47 and 3/6), not 47.3 decimal overs. A tenth digit of 6 or more is rejected because six balls complete an over. Other fractions, such as 47.5 already converted, are treated as true decimal overs.
Values must stay within one million so a full tournament still fits, while pathological billions are rejected. Example: 250 runs scored in 50 overs and 200 runs conceded in 50 overs yield 1.000. Prefer bare numbers over formatted strings; commas and thousands separators are not parsed as input.
Where an ICC net run rate calculator earns its keep
Tournament desks and World Cup recap pages need a reproducible NRR so a group table, a broadcast graphic, and a newsroom spreadsheet never disagree on whether 300 in 50 overs against 250 in 47.3 is 0.737. A publisher ranking for net run rate calculator or ICC NRR is targeting people who already have four aggregates and want the three-decimal signed rate, not a projection system, not a Duckworth-Lewis-Stern explainer, and not a fantasy points engine.
Franchise and domestic-league managers who sit in a table-deciding round need the same number the official standing printed, so they can compare two sides whose points look identical but whose scoring and conceding volumes are not. Classroom and scoring-certification courses that teach tournament arithmetic need an oracle that rejects zero overs and still returns 0.000 when a side scored nothing in a completed innings, because those two cases are how students confuse no rate yet with a rate of zero.
Engineers writing scorebook and standing tests pin known-good pairs—250 over 50 minus 200 over 50 as 1.000, 300 over 50 minus 250 over 47.3 rounded to 0.737, and a zero-over rejection—so a reporting library cannot silently treat NRR as run difference over matches played. Failed validation does not consume balance.
What you can do with it
World Cup and tournament tables
Enter group-stage runs scored, overs faced, runs conceded, and overs bowled to publish a three-decimal NRR that matches the official standing, including truncated innings written as 47.3.
League and franchise tie-breakers
Convert two sides that finished on the same points into net run rates against each team's scoring and conceding volume so table order is visible before the last round.
FAQ
How do I calculate cricket net run rate (ICC NRR)?
NRR equals runs scored divided by overs faced, minus runs conceded divided by overs bowled, rounded to three decimal places. Example: 250 in 50 overs against 200 in 50 overs is 1.000.
What happens if overs faced or overs bowled is zero?
Net run rate divides by each overs total, so a zero or negative denominator is rejected and is not billed.
How are overs like 47.3 treated?
Cricket scorebooks write .1 through .5 for one to five balls. This calculator converts those tenths to sixths of an over, so 47.3 is 47 overs plus three balls (47.5 decimal overs). A ball digit of 6 or more is rejected. Other fractions are treated as true decimal overs.
What if a team is all out before facing its full quota of overs?
ICC playing conditions treat that innings as having faced the full quota. Pass the adjusted overs yourself (for example 50 in a fifty-over innings); this calculator applies the four-number identity to the totals you send and does not infer all-out status.
Can net run rate be negative?
Yes. It is a signed rate, so a side that concedes faster than it scores sits below zero, even after winning more matches than it lost. Being rolled for 80 in 30 overs while conceding 240 in 50 is deeply negative.
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/sports/icc \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"runs_scored":250,"overs_faced":50,"runs_conceded":200,"overs_bowled":50}'const res = await fetch("https://api.kit.forhosting.com/sports/icc", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"runs_scored": 250,
"overs_faced": 50,
"runs_conceded": 200,
"overs_bowled": 50
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/sports/icc",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"runs_scored": 250,
"overs_faced": 50,
"runs_conceded": 200,
"overs_bowled": 50
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/sports/icc", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"runs_scored":250,"overs_faced":50,"runs_conceded":200,"overs_bowled":50}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"runs_scored":250,"overs_faced":50,"runs_conceded":200,"overs_bowled":50}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/sports/icc", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"runs_scored": 250,
"overs_faced": 50,
"runs_conceded": 200,
"overs_bowled": 50
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "sports.icc",
"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 | 1000000 |
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
Successful calls are billed at $0.002; invalid input is not charged.
Input contract, cricket overs, and response shape
POST a JSON body with four required fields. runs_scored is the official run total while batting over the window you care about and must be a non-negative integer; aliases RS, runs_for, scored, and runs are accepted so a scorebook export does not need a rename step. overs_faced is the overs total over the same batting window and must be a strictly positive finite number, because net run rate divides by overs faced; aliases OF, overs_for, and faced are accepted. runs_conceded is the official run total conceded while bowling and must be a non-negative integer; aliases RC, runs_against, and conceded are accepted. overs_bowled is the overs total over the same bowling window and must be strictly positive; aliases OB, overs_against, and bowled are accepted. Each field may arrive as a JSON number or as a numeric string. If a side was all out, pass the full quota of overs the playing conditions entitle that innings to, not the truncated over count; this endpoint does not apply that rule for you. Missing fields, empty strings, non-numeric values, a non-integer run total, an overs total of zero or a negative overs total, an invalid ball digit, or a value outside those limits fail with invalid_input naming the field and are not billed. On success the body echoes the four inputs, returns overs_faced_actual and overs_bowled_actual as the converted over counts used in the division, scoring_run_rate and conceding_run_rate as the two component rates rounded to three decimals, net_run_rate as the signed difference rounded to three decimal places, net_run_rate_text as that same value always written with three digits after the decimal so 1.000 does not collapse to 1 in a display, and a formula string you can print next to the numbers. Pricing for a successful item is a flat $0.002.
Where an ICC net run rate calculator earns its keep
Keep requests small, pin the three-decimal net_run_rate_text in tests, and you get stable cricket arithmetic for widgets, standing pages, and edge workers without standing up a full stats service of your own.
Integration use cases
Scoring classes and standing tests
Students and QA pin 250 in 50 versus 200 in 50 as 1.000, 47.3 as 47.5 decimal overs, and zero overs as invalid_input, matching the ICC identity exactly.
Technical questions
What does the ICC net run rate calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.