Does Turnitin use perplexity and burstiness to detect AI?

Turnitin's model is not explicitly programmed to evaluate "burstiness" or "perplexity" as individual metrics. It is a transformer-based classifier that learns statistical patterns from training data, including patterns in word probability. So the popular claim that Turnitin checks two named scores and flags your text if they fall in the wrong range is wrong about the mechanism, even though the underlying intuition, that word probability is what separates AI text from human text, is not entirely off.

The correction matters because the advice built on the wrong mechanism fails in a specific way. If you believe Turnitin computes a perplexity number, you try to move that number. If what it actually does is classify text by learned word probability patterns across overlapping segments, then moving a single surface metric may or may not change what the classifier sees. We have written about what AI detectors measure in general terms; this article narrows to the one detector and the two metrics most people name.

Turnitin's AI writing detection capabilities FAQ contains a direct denial. The sentence people keep quoting, and the sentence immediately after it that they keep dropping:

"Our model is not explicitly programmed to evaluate specific signals such as "burstiness," "perplexity," or other individual metrics sometimes referenced in public discussions." "Instead, it learns statistical patterns from our training data."

The same paragraph continues: "As a result, its outputs are generated by many learned patterns working together rather than by a small set of transparent, human-readable rules. For that reason, individual predictions may not always be explainable in simple feature-by-feature terms."

Read those four sentences together and the denial has a precise shape. Turnitin is saying: we do not have a module that computes a burstiness number and we do not have a module that computes a perplexity number, and we do not feed those two numbers into a threshold. That is a denial of a specific architecture. It is not a denial that word probability is involved.

Here is the sentence on the same page that turns a simple denial into a more complicated one. Under the question about what parameters or flags the model takes into account, Turnitin writes:

"Our classifiers are trained to detect these differences in word probability and are adept at the particular word probability sequences of human writers."

So the same FAQ that says the model is not programmed to evaluate perplexity also says the classifier is trained to detect differences in word probability. Those two statements are not contradictory, but you have to hold them at the same time to avoid misreading either one.

Perplexity, as a concept, is a measure of how predictable a sequence of words is under a language model. A language model assigns probabilities to words, and perplexity summarizes how surprised the model was by the actual next word at each step. Low perplexity means the model found the text predictable. High perplexity means it did not. The reason AI-generated text tends to have low perplexity is that language models produce text by sampling from their own probability distributions, so the output falls into a band of probabilities the model already considered likely.

That is the connection. Turnitin does not compute a perplexity score and check it against a threshold. But its classifier is trained on word probability patterns, and perplexity is one way of summarizing word probability. The denial is about the mechanism, not about the signal.

The practical difference is this. A system that computes perplexity as a named metric gives you a clear target: lower the perplexity number and you lower the chance of being flagged. A system that learns word probability patterns as part of a larger classifier gives you no such clear target, because the classifier is combining many learned patterns and the output is not reducible to a single score you can track. We looked at how to read a Turnitin AI writing report and the number on it is a single percentage, but that percentage is an aggregation of many segment-level classifications, not a reading from a perplexity gauge.

Turnitin's published description of how the model processes a submission is on the same FAQ page:

"When a paper is submitted to Turnitin, sentences from the submission are extracted and segmented into overlapping sections for prediction analysis. Each segment is classified by the AI detection model and given a value between 0 and 1, denoting the probability of the text being likely human or AI-generated. Each qualifying sentence within these segments inherits the segment's score. Since segments overlap, some sentences may have multiple scores, which are then pooled into a single score. These sentence scores are further aggregated and used to compute the overall document AI writing score."

So the pipeline is: extract sentences, cut them into overlapping segments, classify each segment on a 0 to 1 scale, let qualifying sentences inherit scores from the segments that cover them, pool overlapping scores, then aggregate everything into the document percentage you see on the report.

The overlap is the part that breaks the simple metric story. A sentence near the edge of one segment is also inside the next segment, so it picks up scores from both. When those scores are pooled, what sits on one sentence is partly a function of what sits on its neighbors. A sentence you rewrote to sound less predictable can still inherit a high score from a segment that also covers the sentence next to it, if that neighbor carries patterns the classifier learned to associate with AI text.

This is why why detectors disagree so often on the same document. Two classifiers trained on different data, segmenting at different boundaries, pooling in different ways, will produce different scores on the same text even if they are both reacting to the same underlying word probability patterns. The disagreement is not noise around a true perplexity reading. It is two different learned classifiers producing two different aggregations.

If Turnitin computed a perplexity score, the strategy would be straightforward. You would measure your text's perplexity, rewrite until the number moved, and resubmit. Tools that claim to "lower perplexity" are selling exactly that workflow, and their marketing copy is where most of the confusion about Turnitin's mechanism comes from.

But if what Turnitin does is classify segments using a model that has learned word probability patterns along with many other patterns, then the strategy does not hold together. You do not have a number to move. You have a classifier output that responds to the overall distribution of learned features across the whole document, pooled across overlapping windows. A rewrite that makes one passage less predictable in isolation may or may not change the pooled scores that cover it, because the classifier is reading the segment, not the sentence, and the segment includes what is on either side.

There is a second consequence. The same FAQ page defines what the model looks at as qualifying text:

"This qualifying text includes only prose sentences, meaning that we only analyze blocks of text that are written in standard grammatical sentences and do not include other types of writing such as lists, bullet points (short non-sentence structures), or other non-sentence structures."

The next sentence is: "This percentage is not necessarily the percentage of the entire submission." Lists, bullet points, and other non-sentence structures sit outside the analysis. So a rewrite that converts prose into bullet points to break up a pattern is not lowering a perplexity score. It is removing the text from the thing being scored altogether, and the percentage is computed over whatever qualifying prose remains. That is a different operation with a different risk profile, and it is worth understanding which one you are doing.

The burstiness and perplexity story is not random. It comes from early academic work on AI text detection, where researchers did use these two metrics as features in experimental classifiers, and where the difference in distribution between AI and human text along these two axes was measurable and intuitive. A human writer varies sentence length more than a language model does, and a human writer's word choices are less predictable than a model's. Burstiness captured the first, perplexity captured the second.

The story stuck because it is easy to explain, and because it gives a clear action: vary your sentence length, pick less predictable words. Both of those are reasonable things to do. The problem is that Turnitin specifically says it does not build its detector by computing those two named metrics, so the clear action is attached to the wrong description of what the detector does. When the detector evolves, and Turnitin's has evolved several times since 2023, the action stops mapping to anything in the system, but the advice keeps circulating because the story is simple and the original research it came from was real.

This is also why humanizer tools that were built to target perplexity and burstiness as named metrics tend to lose effectiveness over time. The detector they were designed against was never quite the detector Turnitin describes, and as Turnitin's model iterates, the gap between what the tool targets and what the classifier actually reads gets wider.

HumanPen is a document rewriting tool, and the design decision relevant here is that we do not try to move a named metric. We rewrite the passages the AI writing report has flagged, and we do it by changing the actual language of those passages rather than by nudging a number we assume sits underneath the report.

The reason is the one this article has been walking through. If the classifier reads word probability patterns across overlapping segments, then what changes its output is changing the language inside those segments, not moving a score on a dashboard. A tool that tells you it has lowered your perplexity by a certain amount is telling you about a number it computed, not about a number Turnitin computed. The only number Turnitin produces is the percentage on the report, and that percentage is an aggregation of segment-level classifications, not a reading from a perplexity gauge.

Billing counts only the words actually rewritten. If a fresh report on the rewritten text still comes back at 20% or above, you can import that report and re-run just the passages it still flags at no charge, and the output of that run can be taken through the same step again, so it repeats until the report falls below 20%.

What we will not tell you is what your next report will say. Our own page says the tool aims to preserve meaning, structure, terminology, citations, layout and styles while rewriting only the necessary language, and then says to review complex documents after download. Both halves of that are meant.

Does Turnitin check perplexity? Not as a named metric. Turnitin's FAQ says its model is "not explicitly programmed to evaluate specific signals such as 'burstiness,' 'perplexity,' or other individual metrics sometimes referenced in public discussions," and adds that "it learns statistical patterns from our training data." The same page says its classifiers are "trained to detect these differences in word probability," and perplexity is a measure of word probability. So the signal is there, but it is not computed as a standalone score.

Does Turnitin check burstiness? Same answer. Burstiness, which describes variation in sentence length and structure, is not a named metric in Turnitin's model. The classifier may learn patterns related to sentence variation as part of its training, but there is no module computing a burstiness number and checking it against a threshold.

So is the popular explanation completely wrong? Not completely. The intuition behind it, that AI text is more predictable than human text in terms of word choice and sentence structure, is directionally correct. What is wrong is the claim that Turnitin computes two named scores and flags your text based on them. Turnitin says it does not, and the mechanism it describes instead, a transformer classifier reading overlapping segments, is a different architecture with different weaknesses.

If Turnitin does not use those metrics, what does it use? A transformer-based classifier that reads overlapping segments of your text, assigns each segment a probability of being AI-generated, pools those scores across overlapping windows, and aggregates them into a document-level percentage. The classifier is trained on word probability patterns from human and AI text. We covered the segment-level mechanics in more detail in what AI detectors measure.

Why do tools that claim to lower perplexity sometimes work anyway? Because the language changes that lower a computed perplexity score, using less predictable words, varying structure, are also the kind of changes that can shift what a word-probability classifier sees. The tool is targeting the wrong metric, but some of the edits it makes happen to change the right signal. The mismatch shows up over time: as the classifier iterates, the correlation between the tool's target metric and the classifier's actual decision boundary drifts, and the tool loses effectiveness without changing anything about itself.

Does that mean I should stop trying to make my writing less predictable? It means the goal is right but the metric is not. Writing that varies in structure and does not fall into generic patterns is less likely to match what the classifier learned as AI-like. The error is in thinking you are moving a named score on a dial, when what you are actually doing is changing the language the classifier reads across overlapping windows. That is a worthwhile thing to do, it just is not what the popular explanation says you are doing.