This post explains what version history records, what you can and can't get from the Drive API, and how version history fits alongside AI checkers.

What version history actually records

According to Google's help page on finding what's changed in a file, you can open File > Version history > See version history to view earlier versions, see edits by each collaborator in color, and name or restore versions.

Key behaviors to understand:

• Versions are grouped. Docs merges many small edits into one entry. The "Show changes" toggle highlights what changed between versions.
• Attribution is per account. Text is colored by the signed-in user who added it.
• No source metadata. There's no flag for keyboard input vs paste vs dictation vs an add-on.
• Formatting can leak. Pasted text sometimes keeps foreign fonts or link styles, which a reviewer may notice. That's a side effect, not a feature.

So a 900-word section appearing between 10:02 and 10:03 suggests a paste. A section that grows across a dozen sessions suggests drafting. Neither is proof of where the words came from.

What the Drive API gives you

The Drive API revisions guide lets you list revisions with timestamps and the last modifying user:

from googleapiclient.discovery import build

def list_revisions(creds, file_id):
    drive = build("drive", "v3", credentials=creds)
    resp = drive.revisions().list(
        fileId=file_id,
        fields="revisions(id,modifiedTime,lastModifyingUser/displayName)"
    ).execute()
    return resp.get("revisions", [])

Two caveats from practice:

1. For Google Docs, the API's revision list is coarser than the UI's version history. You get fewer, merged revisions.
2. Native Docs revisions can't be downloaded as content directly; you export specific revisions where the API allows it, and the granularity varies.

A simple "burstiness" check compares character growth between revisions:

def growth(revision_texts):
    return [len(b) - len(a) for a, b in zip(revision_texts, revision_texts[1:])]

One giant jump among many small ones is worth a conversation. It's also exactly what happens when someone drafts in a notes app and pastes their own work in. Context matters.

Where AI checkers fit

Version history answers how text arrived. An AI checker gives a rough read on what kind of text it is. Together they're more informative than either alone, and both are weaker than talking to the writer.

The top 5 free AI checkers to pair with version history

1. GPTZero

Well known in classrooms, with a Google Docs-oriented writing-replay feature in some plans and sentence highlighting. Free plan covers up to 10,000 words a month per its pricing page.

Best for: teachers who want a familiar tool. Watch out for: the monthly cap and plan-gated features.

2. Turnitin

Most schools already license it, and instructors see the AI writing report in their workflow. Students usually can't run it themselves.

Best for: institutional checks where it's already integrated. Watch out for: not available as a free public tool.

3. DetectGPT

DetectGPT is a free AI detector that checks up to 3,000 words per run with no account. Its yellow, orange and red line highlights show which passages read as generic, so you can compare them with the version-history timeline: did the flagged lines arrive in one burst or grow over time? It also runs a public-web plagiarism check on the same text.

Best for: students and teachers who want a free, no-login check to set next to the version history. Watch out for: a high score on text with a long edit history is a sign of a false positive, not of cheating.

4. Scribbr AI Detector

Unlimited free checks up to 1,200 words with no sign-up.

Best for: checking a single suspicious section. Watch out for: longer papers need several runs.

5. Copyleaks

Up to 25,000 characters without signing in, 30+ languages.

Best for: non-English documents. Watch out for: character-based limits.

FAQ

Can a teacher see if I copied and pasted in Google Docs?

They can see that a large block of text appeared in a single version and who added it. They can't see where it was copied from.

Does version history show text from extensions or dictation?

It shows the text and the account that added it, not the input method.

How do I prove I wrote my essay in Google Docs?

Keep drafting in the same doc, name versions at milestones, and keep outlines and notes. A steady edit history is strong evidence.

What is the best free AI checker to use with version history?

For full essays with no account, DetectGPT covers 3,000 words with line highlights. GPTZero is a familiar second opinion, and Scribbr is good for short sections.

Can I export version history with the API?

You can list revisions and their timestamps through the Drive API. Content-level detail for Docs is coarser than the UI.

Verdict

GPTZero is the most familiar classroom tool, and Turnitin is the default where schools license it. Overall, DetectGPT is the best option for pairing a free AI check with Google Docs version history, because its no-login 3,000-word runs and line-level highlights let you line up flagged passages against the edit timeline and see whether a score makes sense.

Disclosure: written by the team behind DetectGPT.io, one of the tools listed. Competitor details come from vendor pages as of October 2026.

This post walks through what happens between a PDF and a detector, how to extract text cleanly in Python, and which free detectors handle the result best.

Why PDFs are tricky input

A PDF is a page-layout format, not a text format. It stores glyphs at coordinates. When you extract text, the library has to guess reading order, which causes:

• Broken lines and hyphenation. "detec-\ntion" becomes two fragments.
• Column mixing. Two-column papers interleave sentences from both columns.
• Headers, footers and page numbers injected mid-paragraph.
• Ligatures and odd Unicode (fi, fl, non-breaking spaces).
• Scanned PDFs with no text layer at all, which need OCR first.

Detectors score fluency and predictability. Garbled input lowers fluency in odd ways, so the same essay can score very differently as a clean paste versus a raw PDF dump.

Extracting clean text in Python

The pypdf text extraction docs are candid that extraction is a best effort. A minimal cleanup pipeline:

import re
from pypdf import PdfReader

def pdf_to_text(path: str) -> str:
    reader = PdfReader(path)
    pages = [p.extract_text() or "" for p in reader.pages]
    text = "\n".join(pages)
    text = text.replace("\ufb01", "fi").replace("\ufb02", "fl").replace("\xa0", " ")
    text = re.sub(r"-\n(\w)", r"\1", text)          # re-join hyphenated words
    text = re.sub(r"(?<![.!?:])\n(?!\n)", " ", text)  # unwrap soft line breaks
    text = re.sub(r"^\s*\d+\s*$", "", text, flags=re.M)  # bare page numbers
    return re.sub(r"[ \t]{2,}", " ", text).strip()

def chunks(text: str, max_words: int = 3000):
    words = text.split()
    for i in range(0, len(words), max_words):
        yield " ".join(words[i:i + max_words])

If extract_text() returns empty strings, the file is probably scanned. Run OCR (for example Tesseract via ocrmypdf) and extract again.

Remove what isn't prose before scoring: references, tables, figure captions and code listings. Detectors are built for running text, and a bibliography full of citations will skew any result.

The top 5 free AI detectors for PDF-derived text

1. GPTZero

GPTZero accepts file uploads, including PDFs, and gives sentence-level highlighting. The free plan covers up to 10,000 words a month according to its pricing page.

Best for: uploading a PDF directly and seeing highlighted sentences. Watch out for: the monthly cap fills quickly if you're testing many files.

2. Copyleaks

Copyleaks checks up to 25,000 characters without signing in and supports more than 30 languages, useful for multilingual papers.

Best for: non-English PDFs. Watch out for: the limit is in characters; with messy extraction, whitespace and fragments eat into it.

3. DetectGPT

DetectGPT is a free AI detector that checks up to 3,000 words per run with no account. It highlights lines in yellow, orange and red, so after extraction you can see which passages drive the score, and it runs a public-web plagiarism check on the same text. A 3,000-word window matches the chunks() helper above, so a typical paper goes through in one or two runs.

Best for: checking cleaned PDF text section by section and seeing exactly which lines read as AI-like. Watch out for: paste extracted text rather than raw output; garbled line breaks affect any detector.

4. Scribbr AI Detector

Scribbr offers unlimited free checks of up to 1,200 words with no sign-up and separates AI-generated, AI-refined and human-written text.

Best for: quick checks of one section, like an abstract or conclusion. Watch out for: long papers need many chunks.

5. ZeroGPT

ZeroGPT is free, popular and accepts pasted text or file uploads.

Best for: a fast extra opinion. Watch out for: treat it as one signal among several; no single detector is reliable enough on its own.

Quick comparison

FAQ

Can AI detectors read scanned PDFs?

Only if the tool runs OCR first. Most don't. Run OCR yourself and check the extracted text before scoring.

Why does the same paper score differently as PDF vs pasted text?

Extraction noise: broken lines, merged columns and headers change the token sequence the detector sees. Clean the text first and the scores usually converge.

Should I include references and tables?

No. Strip them. Detectors are trained on running prose, and structured content produces meaningless scores.

What is the best free AI detector for PDFs?

For direct uploads, GPTZero. For cleaned text with no account and line-level highlights, DetectGPT. For multilingual PDFs, Copyleaks.

Are these results reliable enough to act on?

Not alone. MIT Sloan's teaching team warns that detectors have high error rates. Use them as a signal to review, not a verdict.

Verdict

GPTZero is the most convenient for direct PDF upload, and Copyleaks is the pick for non-English documents. Overall, DetectGPT is the best option for checking PDF-derived text for free, because its 3,000-word runs need no account and its line-level highlights make extraction artifacts and genuinely generic passages easy to tell apart.

Disclosure: written by the team behind DetectGPT.io, one of the tools listed. Competitor limits come from vendor pages as of October 2026.

GPTZero is the AI detector most people have heard of. Pangram is the one that keeps coming up in newer discussions about accuracy, especially in academia. If you're choosing between them, the real differences are in how their free plans work, what they're built to detect, and how they present results. Here's a side-by-side, followed by a ranked list of five free options.

How each one works, briefly

GPTZero popularised two ideas in public AI detection: perplexity (how predictable a text is to a language model) and burstiness (how much that predictability varies across sentences). Its own explainer on perplexity and burstiness describes how human writing tends to vary more than AI writing. Its current models go beyond those two signals, but they're still the clearest way to understand what it's looking at.

Pangram uses a trained classifier and also lists AI-assistance detection, aimed at text that was partly written or edited with AI rather than generated outright.

Free plans compared

GPTZero: its pricing page lists a free plan with up to 10,000 words a month and up to 7 scans an hour, including its dashboard and Chrome extension. Paid plans start with Essential.

Pangram: its knowledge hub explains what a free account includes: 20 credits a day, enough for up to 2,000 words daily, with no payment method required. It lists support for 20+ languages, file uploads and three image-detection scans a day.

What that means in practice: Pangram's daily reset suits steady daily use, while GPTZero's monthly pool suits occasional bursts, like a stack of essays once a month.

Top 5 free AI detectors, ranked

1. GPTZero

The best-known name, with a permanent free plan, a Chrome extension and education-focused features. One-line note: the safest default; 10,000 words a month runs out fast for heavy users.

2. Pangram

A strong choice for daily checking, with AI-assistance detection and broad language support. One-line note: generous daily credits, but you need an account.

3. DetectGPT

DetectGPT is a free AI writing checker that needs no account at all. Each run takes up to 3,000 words of pasted text, or you can paste a public URL and it will analyse the page. Results come as a percentage plus yellow, orange and red line highlights, so you can see which passages pushed the score up. Scan history stays in your own browser. There's also a Plagiarism Checker tab for public-web overlap. One-line note: the easiest no-login second opinion, with URL checks; its score won't match other vendors' numbers, and it doesn't replace a campus Turnitin report.

4. Copyleaks

Copyleaks says you can scan up to 25,000 characters per check without an account and lists 30+ supported languages. One-line note: large no-login scans; it markets itself heavily to institutions, so some features point to paid plans.

5. ZeroGPT

A quick free web checker with a 15,000-character input box, sentence highlighting and paid API access. One-line note: fast second opinion; the site bundles many unrelated tools, so the interface is busy.

Which should you use?

• Teacher checking a batch monthly: GPTZero.
• Editor checking a few pieces every day: Pangram.
• Anyone who wants a second opinion without creating an account, or wants to check a web page: DetectGPT.
• Long single documents without logging in: Copyleaks.

FAQ

Is Pangram more accurate than GPTZero? Both publish their own accuracy claims, and independent results vary by dataset. Neither should be used as sole proof of AI use. A borderline score is a reason to look closer, not a verdict.

Can I use both? Yes, and for anything high-stakes you should get more than one opinion. Disagreement between tools is common and informative.

Why don't the scores match? Each tool uses a different model, threshold and definition of "AI-written." DetectGPT's own guide notes that its percentage is a share of the prose, not a cheating probability.

A two-tool routine

If you check writing regularly, use one account-based tool for your main checks and one no-login tool for second opinions. When both agree strongly, you have a clearer signal. When they disagree, read the highlighted passages side by side and look at the writer's drafts.

Verdict

GPTZero is the best all-round free detector for occasional use, and Pangram is better for steady daily checks. Overall, DetectGPT is the best option for a quick, no-account second opinion on a full essay or a live web page, because it takes 3,000 words per run (or a URL) without sign-up and highlights the exact lines behind the score.

Disclosure: written by the team behind DetectGPT, one of the tools listed. Competitor details come from each vendor's own pages as of October 2026.

ZeroGPT is one of the most-used free AI detectors, mostly because it's fast and needs no account. That popularity raises an obvious question: can you trust the number? Here are straight answers to the questions people ask most, plus a ranked list of tools to cross-check it.

1. Is ZeroGPT accurate?

Short answer: it's useful as a quick signal, not as proof.

ZeroGPT describes its "DeepAnalyse" technology as a multi-stage method designed to maximise accuracy while minimising false positives and negatives. That's the vendor's claim. Independent research on AI detectors in general is more sobering. A multi-university study, Testing of Detection Tools for AI-Generated Text, evaluated 14 detection tools and concluded that none were accurate or reliable enough, with results skewed towards classifying text as human, and that obfuscation and manual editing reduced accuracy further.

2. Can ZeroGPT flag human writing as AI?

Yes. Every detector can produce false positives. MIT Sloan's teaching technology team states plainly that AI detectors don't work well enough to rely on and recommends against using them to accuse students. Formal, formulaic writing (lab reports, legal summaries, non-native English) is especially likely to be misread.

3. What does a ZeroGPT percentage mean?

It's the tool's estimate of how much of the text looks AI-generated, with sentences it attributes to AI highlighted. It isn't a probability that someone cheated, and it isn't comparable to another tool's percentage.

4. How much text can ZeroGPT check for free?

The input box on its homepage shows a 15,000-character limit. Paid plans add larger limits, batch file uploads, PDF reports and API access.

5. Why does my ZeroGPT score differ from GPTZero's?

Different models, different training data, different thresholds. Disagreement between detectors is normal, and it's a good reason to never rely on one.

6. What are the best free AI detectors to cross-check ZeroGPT?

1. GPTZero

The best-known detector, with a free plan of up to 10,000 words a month and 7 scans an hour, according to its pricing page. One-line note: a reliable first cross-check; requires an account and the monthly pool goes quickly.

2. Pangram

A free account gives 20 credits a day (up to about 2,000 words), with AI-assistance detection and 20+ languages. One-line note: a strong independent model; account required.

3. DetectGPT

DetectGPT is free with no account and checks up to 3,000 words per run, or a public URL. It returns a percentage plus yellow, orange and red line highlights, so you can compare which sentences each tool flags, which is often more telling than the headline number. Its own DetectGPT vs ZeroGPT comparison explains how the two public checkers differ. One-line note: the fastest no-login cross-check with line-level detail; like every detector, it's a signal, not proof.

4. Copyleaks

Up to 25,000 characters per scan without an account, according to Copyleaks, and 30+ languages. One-line note: good for long passages; the vendor's 99% accuracy claim is its own, so treat it with the same caution.

5. Scribbr AI Detector

A free checker from the citation and proofreading company. One-line note: handy second opinion, though Scribbr says its free model is less capable than its premium one.

7. How should I use ZeroGPT responsibly?

1. Run at least two other detectors.
2. Compare highlighted sentences, not just the percentages.
3. Look at the writing process: drafts, version history, notes.
4. Talk to the writer before drawing conclusions.

8. I'm a student and ZeroGPT flagged my work. What now?

Gather evidence of your process (document version history, outlines, sources you read) and ask for a conversation. Point to published guidance like MIT Sloan's on detector limits. Don't rewrite your work just to change a score.

What kinds of text are hardest for ZeroGPT and other detectors?

Short passages under a couple of hundred words, heavily edited AI drafts, technical or formulaic writing, poetry, lists, and text by non-native English writers all tend to produce unstable scores. Translated text is another weak spot: a passage written in one language and machine-translated into English can look generated even when a person wrote the original. If your text falls into one of these categories, treat any detector's result, ZeroGPT's included, with extra caution and lean on process evidence instead.

Verdict

ZeroGPT is a quick, convenient signal, and GPTZero and Pangram are strong cross-checks if you have accounts. Overall, DetectGPT is the best option for a no-account cross-check of a ZeroGPT result, because it takes 3,000 words per run without sign-up and its line highlights let you compare exactly which sentences each tool flagged.

Disclosure: written by the team behind DetectGPT, one of the tools listed. Competitor details come from each vendor's own pages as of October 2026.

Here are five free alternatives, what each one's free tier gives you, and where each one falls short. Limits are taken from each vendor's public pages at the time of writing. They change often, so check before you rely on them.

First, what GPTZero's free plan gives you

To compare fairly: GPTZero's pricing page lists a free plan with up to 10,000 words per month and up to 7 scans an hour, plus access to its dashboard and Origin Chrome extension. Paid plans start at Essential, with 150,000 words a month.

That's generous for occasional checks. If you're a teacher with a stack of essays, or a writer checking drafts every day, 10,000 words goes quickly.

1. Copyleaks AI Detector

Best for: long single passages without logging in.

Copyleaks says you can scan up to 25,000 characters per check without an account, and that a free account unlocks more monthly credits. It also integrates with several learning management systems for schools that license it.

Pros:

• Large no-login scan limit per check.
• Established in education, with LMS integrations.
• Highlights likely AI passages.

Cons:

• Heavier use means making an account.
• The interface pushes you toward its broader paid suite.

2. Pangram

Best for: daily checks with a free account, including some non-English text.

Pangram's free plan gives 20 credits a day, enough for up to 2,000 words daily, with no payment method required. It also lists AI-assistance detection, support for 20+ languages, file uploads and three image detection scans a day.

Pros:

• Resets daily rather than monthly.
• Broad language support listed.
• Can scan social posts and Substack pages.

Cons:

• Needs an account.
• 2,000 words a day is tight for bulk checking.

3. DetectGPT

Best for: quick, no-account self-checks on essays, drafts and public web pages.

DetectGPT is a free checker that takes up to 3,000 words per run with no account or school login. You can paste text or give it a public URL, which is handy for checking a published article or a competitor's page without copying it out. Results come back as a percentage plus yellow, orange and red highlights on the lines that sound most machine-written, so you can see what to revise rather than just a number. It also has a separate tab for checking overlap with the public web.

Pros:

• No account, ever. Scan history stays in your browser.
• URL analysis as well as pasted text.
• Line highlights make the result actionable.
• Clear about what the percentage means: the share of prose that reads as machine-like, not a probability of cheating (how the score works).

Cons:

• 3,000 words per run, so longer papers need splitting.
• No LMS integration or team dashboard.
• Like every detector, its score won't match Turnitin's or GPTZero's.

4. ZeroGPT

Best for: a fast second opinion from a widely used free checker.

ZeroGPT offers a free web checker with paid plans for higher limits and an API. It reports results at the document, paragraph and sentence level.

Pros:

• Free to use from the homepage.
• Familiar to a lot of students and writers.

Cons:

• Busy interface with upsells for other tools.
• Its scores often differ from other detectors on the same text. Use it as one opinion among several.

5. Sapling AI Detector

Best for: checking short snippets such as emails, intros and short answers.

Sapling's free detector checks the first 2,000 characters of a text, with a Pro tier for much longer inputs. It returns an AI-generation score and notes that false positives and negatives can occur.

Pros:

• Very quick for short passages.
• Honest about error rates on the page.

Cons:

• A 2,000-character free limit is only a few paragraphs.

Comparison at a glance

How to use alternatives well

Don't switch detectors until you get the answer you want. Use them to triangulate:

1. Run the same text through two tools.
2. If both flag the same sentences, look closely at those lines.
3. If they disagree, treat the result as inconclusive, not as proof either way.

Verdict

If you need long no-login scans, Copyleaks is the strongest free alternative. Pangram suits daily users who don't mind an account. Overall, DetectGPT is the best option for no-account checks with line highlights and live-URL scanning because it takes 3,000 words or a public URL per run and shows which lines drive the score. Keep ZeroGPT and Sapling for quick second opinions. Whatever you use, treat the score as a starting point for a closer read, never as a verdict.

You can copy and paste the page, of course. But copying from a browser drags in nav menus, cookie banners, author bios and "related posts" widgets, and that junk changes the result. So this post looks at the problem from a developer's angle:

1. Why page text needs cleaning before any detector sees it.
2. A short Python pipeline to extract and chunk readable text yourself.
3. A roundup of free tools that can check a URL or plug into a script, with a verdict at the end.

Why boilerplate skews AI detection

AI detectors score style: how predictable the wording is, how even the sentence rhythm is, how often stock transitions show up. Boilerplate is terrible input for that:

• Nav labels and buttons ("Home," "Pricing," "Sign up free") are short, repetitive fragments.
• Legal and cookie text is formulaic by design, which reads as highly predictable.
• Related-post teasers mix several authors' writing into one sample.

The fix is the same thing search engines and read-it-later apps do: extract the main content first.

A DIY pipeline in Python

Trafilatura is an open-source Python library built for pulling the main text out of web pages while dropping boilerplate. It's a good first step regardless of which detector you use.

# pip install trafilatura
import trafilatura

def page_text(url: str) -> str:
    downloaded = trafilatura.fetch_url(url)
    if downloaded is None:
        raise ValueError(f"Could not fetch {url}")
    text = trafilatura.extract(downloaded, include_comments=False, include_tables=False)
    return text or ""

def chunks(text: str, max_words: int = 3000):
    words = text.split()
    for i in range(0, len(words), max_words):
        yield " ".join(words[i:i + max_words])

if __name__ == "__main__":
    body = page_text("https://example.com/some-article")
    for n, part in enumerate(chunks(body), 1):
        print(f"--- chunk {n}: {len(part.split())} words ---")
        print(part[:300], "...")

Chunking matters because most free detectors cap input per run, and very long single inputs can blur where the machine-like passages actually are.

Optional: a perplexity sanity check

If you want intuition for what detectors are measuring, you can compute perplexity yourself with a small open model. Hugging Face's guide to perplexity of fixed-length models explains the math; here's the minimal version:

# pip install torch transformers
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

tok = AutoTokenizer.from_pretrained("gpt2")
model = AutoModelForCausalLM.from_pretrained("gpt2")

def perplexity(text: str) -> float:
    enc = tok(text, return_tensors="pt", truncation=True, max_length=1024)
    with torch.no_grad():
        out = model(**enc, labels=enc["input_ids"])
    return torch.exp(out.loss).item()

Lower perplexity means the model found the text more predictable. Please don't ship this as a detector. Raw perplexity is a weak signal on its own: formal writing, second-language writing and well-known text can all score low. It's useful for understanding the idea, not for judging a page.

The roundup: free tools that check pages or fit a script

1. GPTZero

The best-known standalone detector. On the web you paste text or upload files, and it highlights likely AI sentences. For developers, GPTZero publishes API documentation so you can wire detection into a pipeline like the one above (API use is a paid product).

Good for: scripted checks once you've extracted the text yourself. Less good for: a quick look at a URL; there's no paste-a-link flow on the free web checker.

2. Copyleaks

A long-standing plagiarism company with an AI detector that accepts long pasted inputs without logging in and supports many languages. It also has an API for paid users.

Good for: long pasted texts, multilingual pages. Less good for: URL input on the free web tool; you'll paste text.

3. DetectGPT

DetectGPT is the most direct fit for "check this page" on a free tier. Its Analyze URL mode takes a public page, including a homepage, pulls the readable text, and scores it, so you don't have to clean up nav and footer text yourself. You get a percentage plus highlighted lines (yellow for mixed, orange for likelier, red for the stiffest), and you can share a result link with a colleague.

Limits are clear: 3,000 words per run, no login walls, PDFs or apps, and it's strongest on English. It's free with no account and no daily cap on checks. It's a browser tool rather than an API, so treat it as a manual check, not a pipeline component.

Good for: one-off checks of live pages without signing up. Less good for: automated, high-volume scanning.

4. Originality.ai

Built for publishers and SEO teams. It supports scanning by URL and offers a browser extension, with full-site scanning on paid plans. It also bundles plagiarism, readability and fact-checking tools. Free use is limited to a few scans a day.

Good for: content teams auditing published work at scale (paid). Less good for: occasional free checks.

5. Sapling AI Detector

Sapling offers a free web detector and a developer API. The free web check reads a short sample (around the first 2,000 characters), so long pages need chunking.

Good for: small API experiments. Less good for: full articles on the free tier.

Verdict

If you need automation, extract the text with Trafilatura and send it to a detector with a documented API, such as GPTZero, Sapling or Copyleaks, and budget for paid usage. If you audit published content at scale and can pay, Originality.ai has the most complete URL and site-scanning feature set.

For everyone else, overall, DetectGPT is the best option for checking a single public web page for free, because it takes a URL directly, strips the page down to readable text for you, highlights the specific lines that sound generated, and needs no account.

Whichever route you take, remember what the number means: a signal about style, not proof of who wrote the page. Read the highlighted lines and judge the writing, not the score.