This free AI code detector runs without an account: paste code, get an AI-likelihood score back. Three scans a day, up to 50 lines each. No card, no email.
The number worth planning around is the 50, not the three. Length is the binding limit here, not frequency, so on the free tier you are scanning a function at a time rather than a file. That constraint shapes how to use it, which is most of what this page is about.
Concrete, because "50 lines" means different things in different languages.
In practice 50 lines is one function with its docstring, or two or three short ones, or a single class method with its guard clauses. It is not a module, not a file, and not a pull request. Blank lines and comments count, so a well-documented function uses the budget faster than a dense one.
The free and signed-in-free tiers share that 50. A free account raises the daily count from three to five and leaves the length alone. Starter is where the length moves, to 500 lines, which is the first point at which scanning a whole file becomes realistic.
Pick the function you actually have a question about rather than the top of the file. If a reviewer flagged one method, scan that method. Pasting the first 50 lines of a file usually means scanning imports and boilerplate, which is the least informative thing in the repository and will drag the reading toward whatever your formatter produces.
For anything longer, the honest answer is that this tool is not the right shape for it and no amount of splitting fixes that: a score per 50-line chunk does not aggregate into a score for a file. Each scan is independent, and averaging them would be inventing a statistic.
Three is enough to learn what the tool is worth, if you do not waste them on three random files.
Scan one: your cleanest code. This feels backwards and it is the most informative thing you can do. Well-documented code with consistent naming and complete docstrings scores high, because tidiness is what a classifier reads as machine-made. In our own testing a clean Python function came back at 87%. Seeing that happen to code you know you wrote is the fastest way to calibrate what the number is worth. Both measurements are published here.
Scan two: your messiest code. The function with the swearing in the comment and the reference to a ticket from two years ago. Our deliberately human sample scored 68%, nineteen points lower and still only one point below the "likely AI-generated" threshold. Now you know the useful range on your own codebase, which is narrower than you would hope.
Scan three: keep it. Save it for the function you genuinely have a question about, once you know how to read the answer.
The score maps to three labels: 70 or above reads as likely AI-generated, 40 to 69 as mixed signals, and below 40 as likely human-written. Given that a clean human function can land in the eighties, the band to take seriously is the bottom one. A low score is informative. A high score means go and look.
Three things, and the third one is why the whole category has a reputation problem.
It will not name the tool. One scan returns one probability with no attribution, so nothing in it distinguishes one coding assistant from another. If you need to know which assistant produced something, nothing we have seen does that reliably and you should distrust a page that says it does.
It will not score per function. Paste three functions and you get one number for the paste, not three numbers. That is another reason to scan the single thing you care about.
It will not establish who wrote the code. This is the one that matters. The strongest evidence about authorship is your version-control history: a commit series showing the work accumulating, with the approach that got reverted and the variable renamed twice. A score describes how finished text reads. In a disagreement about authorship, the history answers the question and the score does not.
Which has a practical corollary worth more than any scan. If you are being asked to account for code you wrote, do not rewrite it. Show the history. Rewriting replaces an accumulating record with one large change, which is the shape you least want it to have.
And a plain note on what leaves your machine: the code you paste is sent to a model to be processed. For proprietary or client code, that is a decision to take against your own obligations before pasting, not after. Our privacy policy governs retention.
The daily count gates text scans and rewrites; code scanning has its own, and length is the limit that binds.
| Free | Starter | Pro | |
|---|---|---|---|
| Price | $0 | $9.99/mo · $7.49 yearly | $19.99/mo · $14.99 yearly |
| Actions a day (shared) | 3 | 20 | Unlimited |
| Words per scan | 1,500 | 5,000 | 7,500 |
| Words per humanization | 260 | 5,000 | 10,000 |
| Detection a month | No cap | No cap | No cap |
| Humanizer a month | No cap | 40,000 words | 80,000 words |
One action is one scan, one file upload or one rewrite, from a single shared daily count. That daily number is the gate that matters: there is no monthly ceiling on any plan, so what separates the tiers is how often you can work and how long a single piece can be, not how much you get through in a month.
Read the free row together rather than line by line. No monthly cap sounds unlimited and is not: three actions a day at up to 260 words a rewrite is roughly 780 rewritten words in a day. It is a real allowance for checking and fixing specific passages, and it is not a plan for processing a backlog.
Current prices, the Business and Enterprise tiers and regional pricing are on the plans page, which is the page we keep up to date.
Code scanning is not one of those shared actions either. It runs on its own count: 3 scans a day with no account, 5 on a free account, 25 on Starter and no daily limit above that. The binding limit is length, not frequency: 50 lines per scan on free and anonymous, 500 on Starter. So the row above does not cap it, and on the free tier you are scanning a function at a time rather than a file.
Yes: three scans a day at up to 50 lines each, with no account and no card. A free account raises the count to five a day and keeps the same 50-line length. Starter raises the length to 500 lines, which is the first tier where scanning a whole file is realistic. These scans are counted separately from the shared daily actions that gate text scans and rewrites.
One function with its docstring, or two or three short ones, or a single class method with its guards. Blank lines and comments count, so a well-documented function uses the budget faster than a dense one. It is not a module or a file, which is why the advice is to scan the specific function you have a question about rather than the first 50 lines, where you would mostly be scanning imports and boilerplate.
You can run several scans, but the results do not combine. Each scan returns an independent probability for whatever you pasted, and averaging them into a file-level figure would be inventing a statistic rather than measuring one. If file-level scanning is what you need, the length limit on a paid tier is the honest answer rather than chunking on the free one.
Because it is probably tidy. Consistent naming, complete docstrings and uniform structure are what a classifier reads as machine-made, and they are also what a style guide, a formatter and a linter produce. A clean Python function scored 87% in our own testing while a deliberately messy human one scored 68%. The practical consequence is that a high score means go and look, and only a low score is strongly informative.
No. One scan returns one document-level probability with no attribution of any kind, so nothing in the result distinguishes one coding assistant from another. We are stating that plainly because it is commonly advertised in this category, and we have not seen the claim substantiated by anyone.
The code is sent to a model to be processed, because that is how a hosted scanner works. Whether that is acceptable for proprietary or client-owned code is a decision to take against your employment terms, client agreements and company policy before pasting rather than after, and our privacy policy is the document that governs retention. If the code must not leave your machine, a cloud tool is the wrong category rather than the wrong vendor.
Two measurements, five approaches compared, and what none of them prove.
See the numbers →Three scans a day, 50 lines, no account.
Open the tool →The signatures a reviewer can read that a classifier cannot.
Read the post →The prose side, on its own anonymous allowance.
Check a passage →Three scans a day, no account, 50 lines. Start with code you know you wrote and see what the number does.