Bacterial exponential growth calculator
100 bacteria with a 20-minute generation time become 800 after 60 minutes: three doublings, an eightfold increase. Enter the starting count, generation time and elapsed time to get the final population in ideal log-phase growth. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Initial count
- 100
- Generation time
- 20
- Elapsed time
- 60
- Generations
- 3
- Fold growth
- 8
- Final count
- 800
- Log10 final count
- 2.903089987
Under unlimited nutrients a bacterial culture doubles at a roughly constant generation time, so the census after a stated interval follows the closed-form map N equals N-zero times two raised to elapsed time over generation time. This bacterial exponential growth calculator applies that identity exactly. You enter the starting cell or colony-forming-unit count, the generation (doubling) time, and how long the culture has been growing; generation time and elapsed time must share one unit. The model is unconstrained exponential growth; it does not apply a carrying capacity, a lag phase, or a death phase.
What bacterial exponential growth means
During balanced binary fission a well-fed culture doubles every generation time g, so after n equals t over g generations the census is N equals N-zero times two to the n, which is N-zero times two raised to t over g. When g is twenty minutes and t is sixty minutes, n is three and a starting one hundred cells become eight hundred.
The same identity is N equals N-zero times e to the mu t, with specific growth rate mu equal to the natural log of two divided by g; both forms are algebraically equivalent and this calculator reports both the discrete fold two-to-the-n and mu. Generation time is the mean interval between successive population doublings, not the lifetime of one marked cell, and it must be measured in the same unit as elapsed time — minutes with minutes, hours with hours.
The model assumes unlimited nutrients, constant temperature, no lag after inoculation, no death, and no carrying-capacity ceiling: the textbook exponential or log phase that microbiologists sketch as a straight line on a semi-log plot. Real flasks leave that phase when oxygen, carbon, pH, or space becomes limiting, so treat the output as the unconstrained exponential prediction rather than a turbidostat, chemostat, or overnight-stationary forecast.
Search intent for this landing is bacterial exponential growth calculator, final bacterial population from generation time, doubling-time growth, and N equals N-zero times two to the t over g. Use it when you already know the initial count, the generation time, and the elapsed incubation and you want the closed-form final count rather than a fitted logistic or Gompertz curve.
Lab workflows, limits, and related search intent
Teaching labs fix a twenty-minute Escherichia coli doubling time so students see that one hour is three generations and a one-hundred-cell inoculum becomes eight hundred, then change g to show how a slower species stays smaller after the same clock time. Fermentation and media-prep teams use the ceiling to decide whether a starter will theoretically reach a target density before a shift, remembering that the number is an unconstrained exponential and will overshoot once nutrients run out.
Method developers compare the closed-form two-to-the-t-over-g curve against observed colony or turbidity points to see when a culture left log phase. Limits: this tool does not convert optical density to CFU (that is a separate calibration), does not invert a final count to solve for generation time or elapsed time, does not fit a logistic or Gompertz plateau, and does not recommend media or temperature.
Search intent includes bacterial exponential growth calculator, bacterial doubling time population, final CFU from generation time, and N equals N0 times two to the t over g.
What you can do with it
Teaching binary fission and the doubling law
Show students that one hundred cells at a twenty-minute generation time become eight hundred after one hour, then change g or t so they see how n = t/g compounds.
Starter-culture and incubation planning
Convert a known inoculum and a published doubling time into a theoretical final CFU after a planned shift so you can judge whether log-phase density is reachable.
Checking when a culture left exponential phase
Compare an observed plate count or turbidity point against N = N0 × 2^(t/g) to see how far a flask departed from unconstrained log-phase growth.
FAQ
Does this include lag, death, or carrying capacity?
No. The result is the unconstrained exponential N = N0 × 2^(t/g). Real cultures leave log phase when nutrients or space become limiting; treat the number as a theoretical ceiling.
How do I calculate the final bacterial count after a given time?
Divide the elapsed time by the generation time to get the number of doublings, then multiply the starting count by two raised to that number. 100 cells with a 20-minute generation time reach 800 after 60 minutes.
Do generation time and elapsed time need the same unit?
Yes. Use minutes with minutes or hours with hours, because the calculator never converts between them. Mixing units would give a wrong number of generations and a wildly wrong final count.
What is the specific growth rate shown with the result?
It is the natural log of two divided by the generation time, the rate used in the continuous form of the same growth law. Both forms are equivalent, so the final count is the same either way.
What happens if the elapsed time is zero?
Zero elapsed time is accepted. No generation has passed, so two raised to zero is one and the final count equals the starting count.
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/bio/exponential-growth-final \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"initial_count":100,"generation_time":20,"elapsed_time":60}'const res = await fetch("https://api.kit.forhosting.com/bio/exponential-growth-final", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"initial_count": 100,
"generation_time": 20,
"elapsed_time": 60
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/bio/exponential-growth-final",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"initial_count": 100,
"generation_time": 20,
"elapsed_time": 60
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/bio/exponential-growth-final", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"initial_count":100,"generation_time":20,"elapsed_time":60}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"initial_count":100,"generation_time":20,"elapsed_time":60}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/bio/exponential-growth-final", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"initial_count": 100,
"generation_time": 20,
"elapsed_time": 60
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "bio.exponential_growth_final",
"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_generations | 1023 |
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 response returns the number of generations, the fold increase, the final population, its base-ten logarithm, a compact scientific-notation string, and the specific growth rate ln(two) over g. Invalid inputs fail with invalid_input and are not billed.
Input contract, response fields, and validation
Generation time and elapsed time must use the same unit; the calculator never converts minutes to hours. Zero elapsed time is legal and returns the starting count with fold growth one — a useful notebook check that the calculator is not inventing doublings. POST a JSON body with three required finite numbers: initial_count as a positive starting census (aliases n0, N0, initial, starting_count, n_zero, inoculum), generation_time as a positive doubling time (aliases g, doubling_time, gen_time, td, t_d), and elapsed_time as a non-negative incubation interval (aliases t, time, duration, incubation_time). Example: initial_count one hundred, generation_time twenty, elapsed_time sixty returns three generations, fold growth eight, and final_count eight hundred. A non-integer generation count is allowed: five hundred cells with generation_time twenty-five and elapsed_time forty give n equals one point six and a fold of two to the one point six. On success the response echoes the three inputs with stable twelve-decimal rounding, plus generations as t over g, fold_growth as two to the n, final_count as the primary population, log10_final_count for semi-log plots, final_count_scientific as a compact scientific string, specific_growth_rate as ln(two) over g, formula restating N equals N0 times two to the t over g, and a short English message. Missing fields, non-finite strings, boolean types, non-positive initial_count, non-positive generation_time, negative elapsed_time, and more than one thousand twenty-three generations (IEEE-754 overflow) fail with invalid_input and are not billed. Successful work is priced at a flat $0.002 with unit item.
Lab workflows, limits, and related search intent
Typical workflow: convert a plate count or a calibrated optical-density reading into initial_count, look up or measure generation_time for that organism, medium, and temperature, set elapsed_time to the planned incubation, and log final_count or final_count_scientific next to the protocol. Failed validation does not consume prepaid balance. Round-trip checks are straightforward: recompute initial_count times two to the (elapsed_time over generation_time) and confirm equality with final_count within published rounding, then confirm that a missing initial_count flips the response from success to invalid_input with a clear field message. Each successful API call is billed at $0.002.
Technical questions
How do I calculate the final bacterial population after exponential growth?
Send positive initial_count, positive generation_time, and non-negative elapsed_time in the same time unit. The API returns final_count = initial_count × 2^(elapsed_time / generation_time).
Do generation_time and elapsed_time need the same unit?
Yes. Use minutes with minutes or hours with hours. The calculator does not convert units; n is simply elapsed_time divided by generation_time.
Why was my request rejected?
Missing initial_count, generation_time, or elapsed_time; a non-positive starting count or generation time; a negative elapsed time; or more than 1023 generations fails with invalid_input and is not billed.
What does the bacterial exponential growth calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.