PCR product yield copies calculator
See how far a PCR can go in theory: 100 starting copies after 30 cycles at 100% efficiency become 107,374,182,400 amplicon copies, about 1.073742 × 10¹¹. Lower the efficiency to see how quickly that ceiling drops. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Template copies
- 100
- Cycles
- 30
- Efficiency percent
- 100
- Efficiency
- 1
- Fold amplification
- 1,073,741,824
- Product copies
- 107,374,182,400
- Log10 product copies
- 11.0308998699
Polymerase chain reaction multiplies a starting DNA template through repeated denaturation, annealing, and extension cycles. Each successful cycle multiplies the previous product by one plus the per-cycle efficiency, so the theoretical copy number after n cycles is the starting template copies times (one plus E) raised to n. This PCR product yield copies calculator applies that closed-form exponential exactly: you enter starting template copy number, cycle count, and optional percent efficiency (one hundred percent means perfect doubling). It returns theoretical product copies, fold amplification, the base-ten logarithm of copies, and a compact scientific-notation string for lab notebooks.
What theoretical PCR copy yield means
The theoretical PCR product yield in copy number follows the exponential map N equals N-zero times (one plus E) to the n, where N-zero is the number of template molecules present at the start of cycling, n is the number of completed thermal cycles, and E is the per-cycle amplification efficiency expressed as a fraction between zero and one.
When efficiency is one hundred percent, E equals one and the formula collapses to the familiar doubling law N equals N-zero times two to the n: thirty cycles from one hundred starting copies produce one hundred times two to the thirty, or one hundred seven billion three hundred seventy-four million one hundred eighty-two thousand four hundred theoretical amplicon molecules. When efficiency is ninety percent, the multiplier each cycle is one point nine instead of two, so the same thirty cycles yield far fewer copies than the ideal doubling curve.
Efficiency of zero percent means the template is not copied at all: the fold amplification is one and the product copy number equals the starting count. Cycle zero is allowed and simply returns the starting template, which is useful when you want a notebook check that the calculator is not inventing amplification. The model is closed-form and deterministic; it does not simulate each cycle as a stochastic branching process, does not consume deoxynucleotides, and does not enter a plateau.
Real reactions leave the exponential phase when primers, polymerase, or nucleotides become limiting, so treat the output as an upper-bound theoretical yield rather than a plate-reader prediction. Use this landing when the search intent is PCR product yield in copies, amplicon copy number after n cycles, or theoretical PCR amplification from a known template count.
Workflows, limits, and related search intent
Cloning labs use the ceiling to decide whether thirty versus thirty-five cycles can theoretically reach a visible band from a scarce template. Method developers compare the ideal (one plus E) to the n curve against observed quantification cycle values to see how far a reaction departed from exponential growth. Teaching labs can fix efficiency at one hundred percent so students focus on the doubling law, then drop it to eighty or ninety percent to show how a small efficiency loss compounds over many cycles.
Limits: this tool does not convert copies to nanograms (that needs amplicon length and average mass per base pair), does not invert a quantification cycle to starting quantity, does not fit a five-parameter logistic plateau, and does not recommend annealing temperatures. Search intent for this landing includes PCR product yield copies calculator, theoretical amplicon copy number, DNA copies after PCR cycles, and PCR amplification yield from starting template.
What you can do with it
qPCR method development ceiling
Compare an observed amplification curve against the closed-form N = N0 × (1 + E)^n prediction to see when a reaction left the exponential phase.
FAQ
What efficiency should I use?
Use 100 for a theoretical doubling ceiling (N = N0 × 2^n). For a realistic assay, enter the percent efficiency from a qPCR standard curve (for example 90 or 95). Send 95, not 0.95.
Does this calculator include the PCR plateau?
No. The result is the closed-form exponential N = N0 × (1 + E)^n. Real reactions leave exponential growth when reagents become limiting; treat the number as an upper-bound theoretical yield.
How many copies do 30 PCR cycles make from 100 template copies?
At 100% efficiency each cycle doubles the product, so 100 copies become 107,374,182,400 after 30 cycles, a fold amplification of 1,073,741,824. Real reactions plateau earlier, so read it as a theoretical ceiling.
Do I enter the efficiency as a percent or as a fraction?
As a percent. Type the percentage itself, with 100 meaning perfect doubling; a fraction between zero and one in that box would be read as an almost failed reaction and give far too few copies.
What happens with zero cycles or 0% efficiency?
Both simply return your starting template. With zero cycles nothing has run yet, and at 0% efficiency nothing is copied, so the fold amplification is 1. That makes a handy check that no amplification is being invented.
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/pcr-amplicon-copies \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"template_copies":100,"cycles":30}'const res = await fetch("https://api.kit.forhosting.com/bio/pcr-amplicon-copies", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"template_copies": 100,
"cycles": 30
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/bio/pcr-amplicon-copies",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"template_copies": 100,
"cycles": 30
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/bio/pcr-amplicon-copies", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"template_copies":100,"cycles":30}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"template_copies":100,"cycles":30}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/bio/pcr-amplicon-copies", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"template_copies": 100,
"cycles": 30
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "bio.pcr_amplicon_copies",
"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_cycles | 80 |
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
Invalid inputs fail with invalid_input and are not billed. This is a theoretical exponential model; it does not fit a plateau, primer depletion, or enzyme death.
Input contract, response fields, and validation
Example: one hundred starting copies, thirty cycles, and one hundred percent efficiency returns fold amplification two to the thirty and product copies one hundred times that fold. The same starting count at ninety percent efficiency uses base one point nine and a smaller product. Do not send efficiency as a zero-to-one fraction in the percent field: ninety-five percent is ninety-five, not zero point nine five. POST a JSON body with required template_copies as a finite positive starting copy number—aliases include n0, starting_copies, initial_copies, and n_zero—and required cycles as an integer from zero through eighty (aliases n, pcr_cycles, cycle_count). Optional efficiency_percent defaults to one hundred for perfect doubling; when present it must lie between zero and one hundred inclusive (aliases efficiency_pct, percent_efficiency, e_percent). On success the response echoes template_copies, cycles, and efficiency_percent with stable twelve-decimal rounding, plus efficiency as the fraction E, fold_amplification as (one plus E) to the n, product_copies as the primary theoretical yield, log10_product_copies for plots that use a log scale, product_copies_scientific as a compact scientific string, formula restating N equals N0 times (one plus E) to the n, and a short English message. Missing fields, non-finite strings, boolean types, non-positive template_copies, non-integer cycles, cycles outside zero through eighty, and efficiency_percent outside zero through one hundred fail with invalid_input and are not billed. Successful work is priced at a flat $0.002 with unit item.
Workflows, limits, and related search intent
Typical workflow: convert a known template mass or a digital-PCR count into starting copies, choose the cycle number you intend to run or already ran, set efficiency_percent from a quantitative PCR standard-curve estimate or leave it at one hundred for a theoretical doubling ceiling, and log product_copies or product_copies_scientific next to the protocol. Failed validation does not consume prepaid balance. Round-trip checks are straightforward: recompute template_copies times (one plus efficiency_percent over one hundred) to the cycles and confirm equality with product_copies within published rounding, then confirm that a missing template_copies flips the response from success to invalid_input with a clear field message.
Integration use cases
Endpoint PCR and cloning yield planning
Convert a known starting template count into a theoretical amplicon copy ceiling after 25–35 cycles so you can judge whether a scarce insert can reach a visible band.
Teaching the doubling law and efficiency loss
Show students that 100% efficiency is N0 × 2^n, then drop efficiency_percent to 90 to demonstrate how a small per-cycle loss compounds across a full PCR program.
Technical questions
How do I calculate theoretical PCR product copies?
Send positive template_copies and integer cycles (0–80). Optional efficiency_percent defaults to 100. The API returns product_copies = template_copies × (1 + E)^n with E = efficiency_percent / 100.
Why was my request rejected?
Missing template_copies or cycles, non-positive starting copies, non-integer cycles, cycles outside 0–80, or efficiency_percent outside 0–100 fail with invalid_input and are not billed.
What does the PCR product yield copies calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.