Mutation frequency calculator
Turn a colony count into mutants per cell: 50 resistant colonies from 100000000 viable cells plated means one mutant in every 2000000 cells, a figure you can compare across cultures and screens. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Mutant colonies
- 50
- Viable cells
- 100,000,000
- Mutation frequency
- 0.0000005
- Cells per mutant
- 2,000,000
Mutation frequency is the observed fraction of mutant cells in a plated culture: mutant colonies counted on selective medium divided by the total number of viable cells that were actually plated. Students, fluctuation-test authors, and quality-control microbiologists need that ratio as mutants per cell, not as a raw colony tally that still hides the dilution and volume used to seed the plate. This mutation frequency calculator accepts the mutant colony count and the total viable cells plated, divides the first by the second, and returns the frequency together with a one-in-N reading when any mutants were scored. A zero or negative total cell count is rejected as invalid input because that denominator would make the frequency undefined or non-physical.
What mutation frequency means and how the ratio is computed
In a typical resistance or auxotrophy screen you plate a known number of viable cells onto selective medium and count the colonies that grow. Those colonies are the numerator. The denominator is not the volume you pipetted and is not the optical density of the flask: it is the total number of colony-forming units that actually landed on the plate after dilution and volume have already been applied.
Mutation frequency is that quotient, conventionally written f equals mutant colonies over viable cells plated, and the unit is mutants per cell. Fifty resistant colonies from one hundred million viable cells is five times ten to the minus seven mutants per cell, which is the same statement as one mutant in two million cells. Zero mutant colonies is a legitimate observation and yields frequency zero.
The model is a snapshot of one culture, not a rate. Do not send CFU per millilitre unless you have already multiplied by the plated volume and the dilution factor.
What you can do with it
Classroom plating homework
Let students submit mutant colony counts and viable cells plated and check the mutants-per-cell frequency against the f = mutants / N identity.
Per-culture frequency in a fluctuation test
Compute the observed frequency of each independent culture before you feed the set into a Luria–Delbrück or Lea–Coulson rate estimator.
QC resistance screens and exam auto-grading
Give technicians and graders a deterministic mutation-frequency oracle that rejects a zero or negative total cell count instead of inventing a ratio.
FAQ
Is mutation frequency the same as mutation rate?
No. Frequency is the observed proportion of mutants in one culture. Mutation rate is mutations per cell per generation and needs a fluctuation test with several independent cultures.
How do I calculate mutation frequency from colony counts?
Divide the mutant colonies on the selective plate by the total viable cells you plated. For 50 colonies out of 100000000 cells, that is one mutant in every 2000000 cells.
What should I enter as the number of viable cells?
The colony-forming units that actually landed on the plate, after dilution and plated volume are applied. If you only have a count per millilitre, multiply it by the plated volume and the dilution factor first.
What if no mutant colonies grow?
Zero mutant colonies is a valid observation and gives a frequency of zero. The one-in-so-many reading only appears when at least one mutant was scored.
Can I use it for a fluctuation test?
Yes, to get the observed frequency of each independent culture before you feed the set into a rate estimator such as Luria–Delbrück. Each result is a snapshot of one culture, not a mutation rate.
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/mutation-frequency \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"mutant_colonies":50,"viable_cells":100000000}'const res = await fetch("https://api.kit.forhosting.com/bio/mutation-frequency", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"mutant_colonies": 50,
"viable_cells": 100000000
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/bio/mutation-frequency",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"mutant_colonies": 50,
"viable_cells": 100000000
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/bio/mutation-frequency", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"mutant_colonies":50,"viable_cells":100000000}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"mutant_colonies":50,"viable_cells":100000000}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/bio/mutation-frequency", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"mutant_colonies": 50,
"viable_cells": 100000000
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "bio.mutation_frequency",
"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 mutation frequency means and how the ratio is computed
Mutation rate asks how many mutational events occur per cell per generation and needs several independent cultures plus a Luria–Delbrück, Lea–Coulson, or MSS estimator; this endpoint does not fit those models. Keep mutant_colonies and viable_cells in matching count units.
Input contract, response fields, and validation errors
POST a JSON body with two required finite numbers: mutant_colonies for the colonies scored on selective medium, and viable_cells for the total viable cells plated. Short aliases work the same way: mutants, mutant_count, colonies, colony_count, mutants_count, total_cells, total_viable, total_viable_cells, cells_plated, viable_count, n, and N. Each field may arrive as a JSON number or as a numeric string, including scientific notation such as 1e8; empty strings, missing keys, non-finite values, and magnitudes beyond the supported absolute limit fail with invalid_input naming the field. mutant_colonies must be non-negative because a negative colony count is not a physical score. viable_cells must be strictly greater than zero: a zero or negative total cell count cannot compute mutation frequency and is the error this calculator exists to catch cleanly instead of returning Infinity or NaN. On success the body echoes both inputs after stable rounding, reports mutation_frequency as mutants per cell, restates the identity in a formula string, and, when the mutant count is positive, includes cells_per_mutant as the reciprocal so a notebook can print one mutant in N cells without a second division. When the mutant count is zero, cells_per_mutant is omitted rather than sent as null. Example: mutant_colonies fifty and viable_cells one hundred million yields mutation_frequency five times ten to the minus seven and cells_per_mutant two million. Failed validation is not billed; successful calls use prepaid KIT balance at the published $0.002 base price per item.
Where a mutation frequency calculator earns its keep
Undergraduate genetics and microbiology courses ask students to recover mutants per cell from a stated colony count and a viable-cell plating; a deterministic oracle marks wrong the case of a zero or negative total cell count instead of silently returning Infinity that a buggy grader might treat as success. Fluctuation-test write-ups still need the per-culture frequency even when the published result is a rate: each independent culture contributes its own f, and this endpoint is the honest quotient for that one flask. Quality-control teams that challenge a production strain or monitor spontaneous resistance can pin the rounded JSON in a notebook so two analysts never disagree on whether fifty colonies from one times ten to the eight cells is five times ten to the minus seven or five times ten to the minus eight. The calculator does not convert CFU per millilitre, does not apply a Poisson correction for jackpots, and does not estimate mutations per generation—send the already-scaled plated count and treat mutation_frequency as the observed proportion in that culture when you chain it into your own rate or confidence-interval code.
Technical questions
How do I calculate mutation frequency from plated colonies?
Send mutant_colonies and a positive viable_cells count (already scaled by dilution and plated volume). The API returns mutation_frequency = mutant_colonies / viable_cells, in mutants per cell.
What happens if the total cell count is zero or negative?
The task fails with invalid_input. A zero or negative viable_cells value cannot be a plating denominator, so the frequency is not computed and the call is not billed.
What does cells_per_mutant mean?
It is the reciprocal of the frequency: viable_cells divided by mutant_colonies. Fifty mutants from 1e8 cells is 2e6, meaning one mutant in two million cells. The field is omitted when the mutant count is zero.
What does the mutation frequency calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.