Two-minute rule task counter
Eight tasks of 0.5, 1, 2, 5, 15, 1.5, 30 and 2 minutes hold five quick wins worth 7 minutes, while three deferred tasks take 50. Paste your estimates and see whether your list is mostly small chores or deep work. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
The two-minute rule from Getting Things Done says that if a task would take two minutes or less, you should do it immediately instead of parking it on a list. Inbox zero sessions, standup prep, and personal kanban boards fill up with tiny actions that never get scored: a quick reply, a file rename, a calendar invite, a one-line status update. This two-minute rule task counter accepts a list of estimated durations in minutes, applies a configurable threshold (default two minutes), and returns how many items qualify for immediate handling plus the total minutes those quick wins would consume. You also get deferred counts and shares so you can see whether your backlog is mostly micro-tasks or deep work.
What the two-minute rule measures and why the counter exists
David Allen’s two-minute rule is a triage heuristic, not a productivity religion: when you are processing an inbox or a captured list, any next action that truly takes about two minutes or less is cheaper to finish now than to track, re-open, and context-switch later. The friction of writing the task down, finding it again, and reloading mental state often exceeds the work itself. Teams abuse the rule when they under-estimate: a “two-minute email” that becomes a twenty-minute thread should never have been classified as immediate.
This calculator does not judge your estimates; it only classifies the numbers you supply. Everything strictly above the threshold is deferred work. Use minutes as the unit; convert half-hour blocks to thirty and sub-minute taps to decimals such as zero point five.
Who uses the two-minute rule counter
Personal productivity coaches and GTD workshops need a deterministic oracle so every student sees the same qualify count for the same duration list during live demos. Product managers triaging a sprint backlog before planning can paste estimate columns and learn how many tickets are actually sub-two-minute chores hiding as stories. Support and ops teams processing ticket queues use the counter to decide whether a morning “burn the small stuff” window will free enough capacity for deep incidents.
Failed validation does not consume balance. Keep lists under a few hundred rows, pin the rounded shares in tests, and you get reproducible two-minute-rule triage for worksheets, LMS modules, and edge workers without hosting custom GTD scoring infrastructure of your own.
What you can do with it
GTD inbox and capture processing
Score a captured list of next-action estimates so you know how many items to clear immediately under the two-minute rule and how many minutes that block will take.
Sprint and backlog triage
Paste story or chore durations before planning to separate sub-threshold micro-tasks from real deferred work and report both count and time shares.
FAQ
What is the two-minute rule?
In Getting Things Done, if a next action takes about two minutes or less, do it immediately instead of tracking it.
Can I change the two-minute threshold?
Omitted threshold defaults to classic GTD’s 2 minutes.
What units should task durations use?
Minutes. Use decimals for sub-minute work (0.5 for thirty seconds). Convert hours to minutes before calling (for example 0.5 hours is 30 minutes).
Why can the share of tasks and the share of time differ so much?
Because quick wins are many but short. In a list of eight estimates, five qualify, which is 62.5% of the tasks, yet they use only 7 of the 57 minutes. That gap shows whether a short clean-up block will really move the list.
Does a task of exactly two minutes count as a quick win?
Yes. Any task whose estimate is less than or equal to the threshold qualifies, so a two-minute task is done now. Only tasks strictly above the threshold are counted as deferred work.
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/biz/two-minute-rule \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"durations":[0.5,1,2,5,15,1.5,30,2]}'const res = await fetch("https://api.kit.forhosting.com/biz/two-minute-rule", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"durations": [
0.5,
1,
2,
5,
15,
1.5,
30,
2
]
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/biz/two-minute-rule",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"durations": [
0.5,
1,
2,
5,
15,
1.5,
30,
2
]
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/biz/two-minute-rule", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"durations":[0.5,1,2,5,15,1.5,30,2]}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"durations":[0.5,1,2,5,15,1.5,30,2]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/biz/two-minute-rule", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"durations": [
0.5,
1,
2,
5,
15,
1.5,
30,
2
]
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "biz.two_minute_rule",
"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
What the two-minute rule measures and why the counter exists
You send an ordered list of non-negative durations in minutes—one number per task—and an optional threshold_minutes (default two). Every duration less than or equal to the threshold is a qualify: it counts toward qualify_count and its minutes add to qualify_minutes. The endpoint also returns total_tasks, total_minutes, defer_count, defer_minutes, and two percentage shares: qualify_task_share (what fraction of items are quick wins) and qualify_time_share (what fraction of estimated minutes those quick wins represent). Those two shares often diverge: a backlog can be eighty percent micro-tasks by count but only fifteen percent by time, which is exactly the signal coaches use to decide whether a ten-minute “clear the small stuff” block will move the board. The method string is always two_minute_rule so clients can pin the algorithm in tests.
Input contract, response shape, and error behaviour
Threshold must be a finite number greater than or equal to zero—classic GTD uses two, but personal systems sometimes use one or three. Example: durations zero point five, one, two, five, fifteen, one point five, thirty, two with the default threshold yields five qualifying tasks totaling seven minutes, three deferred tasks totaling fifty minutes, a sixty-two point five percent task share, and a twelve point two eight percent time share after rounding. POST a JSON body with durations, a required non-empty array of non-negative finite numbers (minutes per task). Aliases tasks, minutes, task_durations, and values are accepted. Optional threshold_minutes defaults to two when omitted; aliases include threshold, cutoff, max_minutes, and limit_minutes. Each duration may be a JSON number, a numeric string, or a small object with a minutes or duration field for row-friendly clients. Empty arrays, missing durations, non-array values, negative minutes, NaN, Infinity, and lists longer than five hundred tasks fail with invalid_input and are not billed. On success the body includes threshold_minutes, total_tasks, total_minutes, qualify_count, qualify_minutes, defer_count, defer_minutes, qualify_task_share and qualify_time_share as percentages rounded for stable cross-runtime goldens, plus formula and method strings. Pair the numbers with your own coaching copy if you need bands such as “clear now” versus “schedule”; this endpoint only classifies and sums. It does not reorder your list, invent estimates, or talk to calendar or email APIs.
Integration use cases
Coaching demos and worksheets
Give workshops a deterministic two-minute rule counter so every participant sees the same qualify_count and qualify_minutes for a shared sample list.
Technical questions
How do I use the two-minute rule task counter?
Send durations as a non-empty array of non-negative minutes (optional threshold_minutes, default 2). The response includes qualify_count, qualify_minutes, defer counts, and task/time shares.
What does the two-minute rule task counter cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.