Cricket run rate calculator
145 runs from 18.2 overs is a run rate of 7.909, and chasing 221 with 11.4 overs left needs 6.514 an over: the calculator reads overs as balls, the way scorers do. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Runs scored
- 145
- Overs faced
- 18.2
- Target
- 221
- Overs remaining
- 11.4
- Run rate
- 7.909
- Required run rate
- 6.514
- Runs needed
- 76
- Balls faced
- 110
This cricket run rate calculator turns a score and cricket-style overs notation into two useful measures: the batting side's current runs per over and the rate it must score at to reach a target. Enter runs scored, overs faced, the target score, and overs remaining. The result also reports runs needed and the corresponding ball counts, making the calculation transparent for live match checks, scorecard analysis, coaching exercises, and automated cricket applications.
Calculate the current scoring rate correctly
A cricket run rate describes how many runs a batting team scores per six-ball over. The calculator first converts the supplied overs faced into balls, then divides runs scored by that precise number of overs. This conversion matters because cricket overs notation is not an ordinary decimal.
A value of 18.2 means eighteen complete overs and two additional balls, or 110 balls in total; it does not mean 18.2 mathematical overs. After conversion, the current rate is calculated as runs scored multiplied by six and divided by balls faced. Runs must be a non-negative whole number, and overs faced must represent at least one ball because division by zero cannot produce a meaningful scoring rate.
The digit after the decimal point may only be zero through five. Six balls complete the next over, so an entry ending in .6 is invalid cricket notation and should instead be written as the next whole over.
Understand the required run rate
The required run rate answers a different question: how quickly must the batting side score from now on to reach the stated target? The calculator subtracts runs scored from the target, never allowing the remaining requirement to fall below zero. It then converts overs remaining from cricket notation to balls and calculates required runs multiplied by six divided by remaining balls.
The time available must be interpreted in actual deliveries, so 11.4 overs means eleven overs and four balls, or 70 balls, rather than 11.4 decimal overs. If runs are still needed but overs remaining is zero, the input is rejected because no finite scoring rate can achieve the target. The result assumes every listed delivery is available and does not predict wickets, extras, interruptions, or revised targets.
What you can do with it
Follow a live run chase
Compare the batting side's current rate with the rate needed from the remaining legal deliveries.
Check a scorecard calculation
Convert partial overs into balls and verify published current and required rates independently.
Build cricket teaching examples
Show players and students why cricket overs notation must be converted before division.
FAQ
How is cricket run rate calculated?
Runs scored are multiplied by six and divided by legal balls faced. The result is rounded to three decimal places.
Does 12.3 overs mean 12.3 decimal overs?
No. It means 12 complete overs and 3 balls, for a total of 75 balls.
How is required run rate calculated?
Runs still needed are multiplied by six and divided by legal balls remaining.
What happens if the target has already been reached?
The calculator returns zero runs needed and a required run rate of zero.
Why is zero overs faced rejected?
A current run rate requires division by the amount of play completed, so it is undefined before any ball has been faced.
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/run-rate-cricket-calc \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"runs_scored":145,"overs_faced":18.2,"target":221,"overs_remaining":11.4}'const res = await fetch("https://api.kit.forhosting.com/sports/run-rate-cricket-calc", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"runs_scored": 145,
"overs_faced": 18.2,
"target": 221,
"overs_remaining": 11.4
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/sports/run-rate-cricket-calc",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"runs_scored": 145,
"overs_faced": 18.2,
"target": 221,
"overs_remaining": 11.4
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/sports/run-rate-cricket-calc", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"runs_scored":145,"overs_faced":18.2,"target":221,"overs_remaining":11.4}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"runs_scored":145,"overs_faced":18.2,"target":221,"overs_remaining":11.4}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/sports/run-rate-cricket-calc", 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": 145,
"overs_faced": 18.2,
"target": 221,
"overs_remaining": 11.4
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "sports.run_rate_cricket_calc",
"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. |
Technical notes
Calculate the current scoring rate correctly
The displayed run_rate is rounded to three decimal places, while the underlying inputs remain unchanged.
Understand the required run rate
Suppose a chase needs 221 and the team has 145; the runs_needed value is 76. If the target has already been reached, both runs_needed and required_run_rate are zero, even when no deliveries remain.
Use the result in match analysis
When the required rate is higher than the current rate, the batting side must accelerate relative to its performance so far. When it is lower, the side has scoring-rate room, although wickets and match conditions may still make the chase difficult. For historical analysis, enter the target that applied at that point in the innings rather than a later revised figure. For live use, update both the score and remaining overs after each legal ball. Compare run_rate with required_run_rate to describe the immediate pressure of a chase. The returned balls_faced and balls_remaining fields let scorecard tools verify exactly how each overs entry was interpreted, which is especially useful around partial overs. API automation costs $0.002 per request. This calculation provides arithmetic context only; it is not a win-probability model and makes no claim about likely match outcomes.
Technical questions
What does an API calculation cost?
Each API request costs $0.002. The browser calculation uses the same deterministic arithmetic.