DEV Community: ProofAI | AI Content Detector

AI Detector vs Plagiarism Checker: What's the Difference?

ProofAI | AI Content Detector — Mon, 02 Nov 2026 02:50:42 +0000

Short answer: a plagiarism checker asks was this copied? It compares your text with web pages, journals and earlier submissions and shows matching passages as a similarity percentage. An AI detector asks was this written by an AI model? It looks at the writing itself, not at other sources. A text can be fully original and still AI-written, or written by you and still copied. That is why many colleges now look at both.

This guide explains what each tool does, which free plagiarism checkers exist, what Turnitin and DrillBit check, and how to check your own work before you submit.

The difference in one table

	Plagiarism checker	AI detector
Question it answers	Was this copied from somewhere?	Did an AI model write this?
How it works	Compares your text with a database of web pages, papers and submissions	Looks for patterns typical of AI-generated text in the writing itself
Result	Similarity % plus the matching sources	AI probability plus the passages that look AI-written
Catches	Copy-paste, close paraphrase, missing citations	ChatGPT, Gemini or Claude text, even if it is "original"
Misses	AI-written text that copies nothing	Copied human text (it is not AI)
Examples	Turnitin Similarity, DrillBit, iThenticate, Grammarly, Quetext, Duplichecker	ProofAI, GPTZero, Turnitin's AI writing report

Why you might need both

Generative AI changed what "original" means. A ChatGPT essay usually does not copy any one source, so it can pass a plagiarism check with a low similarity score. The reverse also happens: a student who wrote every word but forgot quotation marks around a paragraph from a textbook gets a high similarity score while an AI detector shows nothing unusual.

So the two checks answer different questions. Universities use the plagiarism report for the official similarity rules (in India, the UGC 2018 regulations set levels from up to 10% to above 60% for research work, as quoted in the MANUU code of ethics), and a separate AI check where their policy covers AI use. Our guide Turnitin vs DrillBit vs iThenticate covers which tool Indian universities use.

Free plagiarism checkers

If you only need to check for copied text, these are common options. Limits change often, so check the tool's own page before you rely on it:

Quetext: the free plan includes a plagiarism check and an AI content check, each for up to 1,000 words (Quetext pricing).
Grammarly: checks text for duplicate content; its Premium plan highlights the passages that need a citation (Grammarly plagiarism checker).
Duplichecker: a free online plagiarism checker that many students in India use for quick checks of short texts.
Your university's tool: if your institution has Turnitin or DrillBit, that is the report that counts for submission. Ask your library or research cell how to get a check.

Free checkers search smaller databases than Turnitin or DrillBit, which also compare against earlier student submissions and subscription journals. A low score on a free tool does not guarantee the same score on your university's report.

What Turnitin and DrillBit check

Turnitin produces a Similarity Report (plagiarism) and, on licences that include it, a separate AI writing report. The AI report only appears when a file has at least 300 words of long-form prose in a supported language (Turnitin). See Can Turnitin detect AI in a PDF?.

DrillBit is the plagiarism checker that the Ministry of Education's ShodhShuddhi programme has offered to Indian higher education institutions since October 2023 (ShodhShuddhi). Whether a DrillBit report includes an AI check depends on your institution's setup.

Where ProofAI fits

ProofAI is an AI detector, not a plagiarism checker. It does not compare your text with other sources and cannot produce a similarity report. What it does:

Checks text, PDF and Word files and images for AI-generated content, free for 10 checks a day without an account (free AI detector).
Shows which sentences look most AI-written, so you can rewrite them in your own voice.
Works on the files you actually submit, including long PDFs (PDF and Word AI checker).

Use a plagiarism checker for citations and copied text, and an AI detector for AI-written passages. Neither result is proof on its own.

A simple routine before you submit

Fix citations first: quotation marks around every quote, every source in your reference list.
Run a plagiarism check with your university's tool or a free checker, and fix any passage that matches a source without a citation.
Run an AI check on the same file. If a passage reads as AI-written, rewrite it with your own examples and reasoning.
Keep your drafts and notes. Version history is the best evidence if your work is ever questioned.
Disclose AI use where your course or university asks for it.

What neither tool can do

Plagiarism checkers can flag common phrases and properly cited quotes; AI detectors can flag formal or non-native English writing that a person wrote. Both give a starting point for a human review, never a verdict. If a result looks wrong, ask your teacher or supervisor to look at the highlighted passages with you.

FAQ

Is an AI detector the same as a plagiarism checker?
No. A plagiarism checker finds text copied from other sources; an AI detector estimates whether an AI model wrote the text. They answer different questions, so many institutions use both.

Can a plagiarism checker detect ChatGPT?
Usually not on its own, because AI-generated text rarely copies one source word for word. Some tools, like Turnitin, add a separate AI writing report on licences that include it. To check a text for ChatGPT yourself, use a ChatGPT checker.

Which is the best free plagiarism checker?
Quetext's free plan checks up to 1,000 words; Grammarly and Duplichecker also offer free checks. For official submissions, your university's Turnitin or DrillBit report is the one that counts.

Does ProofAI check plagiarism?
No. ProofAI is an AI detector for text, documents and images. Use it alongside a plagiarism checker, not instead of one.

Do I need both checks for my assignment?
If your course has rules on both copying and AI use, yes. Run the plagiarism check for citations and the AI check for AI-written passages before you submit.

Conclusion

A plagiarism checker tells you whether you copied; an AI detector tells you whether a machine wrote it. Check citations first, then check for AI-written passages, keep your drafts, and you will be ready for whichever report your teacher or university runs.

Originally published on ProofAI.

Turnitin vs DrillBit vs iThenticate: Which Do Indian Universities Use?

ProofAI | AI Content Detector — Mon, 02 Nov 2026 02:50:06 +0000

Short answer: many Indian universities check theses and dissertations with DrillBit, which the government's ShodhShuddhi programme has provided to higher education institutions since October 2023. Turnitin is used by universities and colleges that buy their own licence, mostly for coursework. iThenticate is Turnitin's tool for researchers, journals and publishers. All three are plagiarism checkers first; AI writing detection is an extra that depends on the product and the licence your institution has.

If your department tells you to "get a plagiarism report", this guide explains what that report is, which tool is likely behind it, how the UGC similarity levels work, and what an AI detector can and cannot add.

The three tools at a glance

	DrillBit	Turnitin	iThenticate
Made by	DrillBit (Indian company)	Turnitin	Turnitin
Main use in India	Theses, dissertations, research papers at universities	Coursework and assignments where the institution has a licence	Research manuscripts, journals, publishers
How institutions get it	Free to eligible higher education institutions through INFLIBNET's ShodhShuddhi programme since 1 Oct 2023, or a direct licence	Institutional licence	Institutional or publisher licence
Plagiarism (similarity) check	Yes	Yes	Yes
AI writing check	Part of its "AI content integrity" platform; depends on the institution's setup	Yes, on licences that include it	Yes in iThenticate 2.0, as an add-on licence
Who usually runs it	University library or research cell	Teacher or LMS when you submit	Researcher, journal or research office

Sources: ShodhShuddhi (INFLIBNET), DrillBit, Turnitin on AI detection in iThenticate 2.0, Turnitin AI writing report requirements.

DrillBit and ShodhShuddhi

ShodhShuddhi is the Ministry of Education's plagiarism-check initiative run by the INFLIBNET Centre in Gandhinagar. It started in 2019 with Ouriginal (formerly Urkund). That contract ended on 30 September 2023, and from 1 October 2023 INFLIBNET has offered DrillBit-Extreme to higher education institutions under the same programme, with full service from 1 November 2023 (ShodhShuddhi).

In practice this is why so many PhD scholars and postgraduate students in India now receive a DrillBit report: the university library or research cell runs the thesis through it before submission. ShodhShuddhi access is given to institutions, so ask your library or research cell how to submit your work.

Turnitin

Turnitin is the best-known plagiarism checker worldwide. In India it is used mainly by institutions that buy a licence, often inside the learning platform where you upload assignments. Depending on the licence, Turnitin can also produce an AI writing report, which is separate from the similarity score. That report only appears when the file meets Turnitin's conditions, such as at least 300 words of long-form prose in a supported language (Turnitin). Our guide Can Turnitin detect AI in a PDF? covers what it reads and skips.

iThenticate

iThenticate is Turnitin's product for research integrity: journals, publishers and research offices use it to check manuscripts before publication. Turnitin has added AI writing detection to iThenticate 2.0, available as a licensed add-on, and reports it as a separate percentage from the similarity score (Turnitin). If a journal asks for an iThenticate report, they usually run it themselves.

How the UGC similarity levels work

The UGC (Promotion of Academic Integrity and Prevention of Plagiarism in Higher Educational Institutions) Regulations, 2018 set four levels of similarity for research work. University policies quote them like this (MANUU code of ethics):

Level	Similarity	Meaning
Level 0	Up to 10%	Minor similarities, no penalty
Level 1	Above 10% to 40%	Penalties apply under the regulations
Level 2	Above 40% to 60%	Stronger penalties
Level 3	Above 60%	The most serious level

Your university's own policy decides exactly what happens at each level, so read it before submitting. These percentages are about similarity to existing sources, not about AI writing.

Plagiarism check vs AI check: not the same thing

A plagiarism checker asks: was this copied from somewhere? An AI detector asks: was this written by an AI model? A thesis can be fully original and still partly AI-written, or written by you and still match published sources too closely. That is why some reports now show two separate numbers.

ProofAI is an AI detector, not a plagiarism checker. It cannot produce the similarity report your university requires, and it does not replace DrillBit, Turnitin or iThenticate. What it can do is let you check your own chapters for AI-like passages before you submit, for free, and see which sentences look AI-written. You can upload a PDF or Word file to our document checker, or see how we compare in Turnitin alternatives in India.

A checklist before you submit your thesis

Ask which tool your university uses and what similarity level it accepts.
Fix citations first: quotes in quotation marks, every source in the reference list. Most high similarity scores come from missing citations, not copying.
Paraphrase properly in your own words and cite the source anyway.
Check your own writing for AI-like passages if you used AI tools for drafting or language help, and rewrite those parts in your voice.
Keep your drafts and notes. If a report is questioned, version history is the best proof of your own work.
Disclose AI use where your university or journal asks for it.

What these tools cannot do

No plagiarism or AI checker is a judge. Similarity tools can match properly cited text or common phrases; AI detectors can wrongly flag human writing, especially formal or non-native English. Results should start a review by a person, not end one. If you think a report is wrong, ask your supervisor or the research cell to look at the highlighted passages with you.

FAQ

Which plagiarism checker do Indian universities use?
Many use DrillBit, provided free to eligible higher education institutions through INFLIBNET's ShodhShuddhi programme since October 2023. Others license Turnitin for coursework, and journals often use iThenticate.

Is DrillBit better than Turnitin?
They serve similar purposes with different databases and licences. What matters for you is which one your university requires, because that is the report it will accept.

Does DrillBit check for AI writing?
DrillBit describes its platform as covering plagiarism detection and AI content integrity. Whether your report includes an AI check depends on your institution's setup.

Can I use ProofAI instead of a UGC plagiarism report?
No. ProofAI checks for AI writing, not similarity to sources, so it cannot replace the plagiarism report your university asks for. Use it to check your own drafts for AI-like passages before submitting.

What similarity percentage is allowed for a PhD thesis in India?
Under the UGC 2018 regulations, up to 10% similarity is Level 0 with no penalty. Your university's policy has the final word.

Conclusion

For most Indian theses the report will come from DrillBit through your university, for coursework it may be Turnitin, and for journal papers iThenticate. Get your citations right, keep your drafts, and if you used AI tools along the way, check and rewrite those passages in your own words before the official check.

Originally published on ProofAI.

How to Spot a Deepfake Video: A Practical Checklist

ProofAI | AI Content Detector — Mon, 02 Nov 2026 02:50:03 +0000

Short answer: slow the video down and look at the face, the mouth and the light first; then take a screenshot of a clear frame and check it, and find where the clip first appeared. No single sign proves a video is fake, but three or four of them together, plus a source you cannot trace, are a strong warning. This checklist takes about five minutes and needs no special software.

Deepfake videos are no longer a lab curiosity. In India, the government's fact-checking unit has repeatedly flagged AI-generated videos of public figures used to sell fake investment schemes, including clips of the Finance Minister promising impossible monthly returns (NewsBytes on the PIB fact check). The same tricks show up in fake job interviews, "leaked" clips and family-emergency scams on WhatsApp.

Step 1: Watch the face closely

Researchers at the MIT Media Lab, who ran the public Detect Fakes project, point out that high-end deepfakes are almost always changes to the face. Their checklist, as summarised in this Illinois State University library guide, asks you to look at:

Cheeks and forehead: is the skin too smooth or too wrinkly, and does its age match the hair and eyes?
Eyes and eyebrows: do shadows fall where you would expect them?
Glasses: is there glare, too much glare, and does it move naturally when the head turns?
Facial hair and moles: do they look real, or slightly painted on?
Blinking: does the person blink too little or too much?
Lips: do their size and colour match the rest of the face?

Pause the video and step through it frame by frame. Many players let you slow playback to 0.25×, and glitches that are invisible at normal speed often show up between frames.

Step 2: Check the mouth and the voice

The mouth is hard to fake. In many deepfakes the teeth look blurred or merge into one white block, and the tongue barely appears. Then listen:

Do the lips move exactly with the words, especially on "p", "b" and "m" sounds where the lips must close?
Does the voice sound flat, oddly clean, or without breathing, background noise or room echo?
Does the accent or the way of speaking match how this person really talks?

Voice cloning is now cheap, so a familiar voice is not proof on its own. If a "relative" or "boss" asks for money on a video call, hang up and call them back on the number you already have.

Step 3: Look at hands, light and the background

AI video generators still struggle with physics and small details:

Hands: fingers that merge, change number or bend the wrong way.
Light and shadows: shadows that flicker, point in different directions, or do not move with the person.
Text in the scene: signs, logos or captions inside the video that change shape between frames.
Edges: a halo or blur where the face meets the hair, ears or neck, especially when the head turns.
Objects: things that appear, disappear or melt into the background.

Step 4: Check key frames with an image detector

You do not need a video tool to test a video. Pause on two or three clear frames that show the face or the main subject, take screenshots, and upload them to an AI image detector. Check more than one frame: a single frame can be misleading, and real videos that were heavily compressed (for example after being forwarded many times) are harder for any detector.

For the spoken words, copy the captions or a transcript into an AI text detector. A script that reads like generic AI text is one more signal, not proof.

ProofAI's own video detection is coming soon; until then, checking frames and the transcript is the most practical route.

Step 5: Trace the source

Most fakes fall apart when you look for where they came from:

Reverse-search a key frame with Google Lens or TinEye. The original clip, often with a different context or date, frequently turns up.
Check the account that posted it: how old it is, what else it posts, and whether the real person or organisation shared the same video on their official channels.
Look for Content Credentials. Some cameras, editing apps and AI tools now attach signed "Content Credentials" (the C2PA standard) to files. You can upload a file to the Content Credentials Verify tool to read them (how the tool works). A missing credential does not mean a video is fake, because most software does not add them yet.
Search the claim, not just the video: if a minister really announced a new scheme, official sites and major news outlets will say so.

Quick reference: the checklist

Check	What to look for	Time
Face	Skin too smooth, odd shadows, glare on glasses, blinking	1 min
Mouth and voice	Blurred teeth, lips out of sync, flat or too-clean voice	1 min
Hands, light, background	Merging fingers, flickering shadows, changing text	1 min
Key frames	Screenshot 2-3 frames, check with an image detector	1 min
Source	Reverse image search, posting account, official channels, Content Credentials	2 min

What to do if you find a deepfake

Do not forward it, even to warn people; share a fact-check instead.
Report it on the platform (YouTube, Instagram, Facebook and X all have options for manipulated or impersonating media).
Report fraud in India on the National Cyber Crime Reporting Portal (cybercrime.gov.in) or by calling the cybercrime helpline 1930, especially if money was asked for or lost.
Ask PIB Fact Check about videos involving the Government of India; they publish debunks of fake clips (example).
If the video uses your face or voice, keep copies and links, report it to the platform, and see our guide to India's AI labelling rules for what platforms must now do.

What this checklist cannot do

No checklist and no detector catches every fake. The best deepfakes pass a casual look, and some genuine videos look strange because of poor lighting, filters or heavy compression. Detection tools give probabilities, not verdicts. There is no method that works every time. Treat the signs above as reasons to verify, and the source check as the deciding step.

FAQ

Can you tell if a video is a deepfake just by watching it?
Sometimes. Faces, mouths, hands and lighting often give cheap deepfakes away, especially when you slow the video down. Good deepfakes can pass a normal viewing, which is why checking the source matters most.

Is there a free AI video detector?
Several online tools claim to detect AI video, with mixed results. A free route that works today is to screenshot key frames and check them with a free AI image detector, and to check the transcript with an AI text detector.

How do I check a video I received on WhatsApp?
Forwarded videos are heavily compressed, so look first at the source: search for the claim, reverse-search a frame, and check official channels. Do not forward it until you know it is real.

What should I do if someone made a deepfake of me?
Save the video, links and account names, report it to the platform, and report it on cybercrime.gov.in or by calling 1930 if it is used for fraud, harassment or blackmail.

Conclusion

Spotting a deepfake is mostly about slowing down: watch the face and mouth frame by frame, check a few frames with an image detector, and trace the clip back to its source before you believe or share it. A few minutes of checking is usually enough to stop a fake from spreading.

Originally published on ProofAI.

How Voice-Clone Detection Works: Audio Deepfake Detection Explained (with Python)

ProofAI | AI Content Detector — Sat, 31 Oct 2026 14:00:00 +0000

Voice cloning went from research demo to everyday scam tool in about two years. A few seconds of someone's voice from a Reel or a WhatsApp note can be enough to clone it, and "family emergency" calls using cloned voices are now a common fraud pattern in India and elsewhere.

So how do you detect a fake voice? In this post we'll look at how audio deepfake detection works under the hood, then write a small Python script that extracts the kinds of features detectors use. It's a learning project, not a production detector, but it'll help you understand what real systems look at and why they still make mistakes.

How voice cloning works (briefly)

Most modern voice clones are produced by a pipeline like this:

Text-to-speech or voice conversion model generates an intermediate representation, usually a mel spectrogram, in the target speaker's style.
A neural vocoder turns that spectrogram into an audio waveform.

Both stages leave subtle traces. Detectors try to find them.

What detectors look for

1. Spectral artifacts from the vocoder

Neural vocoders are good, but not perfect. They can leave:

Unnatural energy patterns in the high frequencies (roughly above 4–6 kHz)
Overly smooth or repetitive harmonic structure
Odd behaviour in the phase of the signal, which humans barely notice

2. Missing "messiness" of real speech

Real speech is full of small imperfections: breaths, mouth clicks, background room tone, tiny variations in pitch and timing. Synthetic speech is often too clean and too regular.

3. Prosody and timing

Pitch (F0) contours, pause lengths and speaking rate in cloned voices can be flatter or more uniform than a real person under stress, which is ironic given how emotional scam calls try to sound.

4. Learned features

State-of-the-art systems don't rely on hand-picked rules. They train deep models on large datasets of real and fake audio. The research community benchmarks these on the ASVspoof challenges, which have run since 2015 and include logical-access (TTS and voice conversion) and deepfake tracks.

Hands-on: extract detector-style features in Python

Let's compute a few features that classic detectors used, and compare a real recording with a synthetic one you generate yourself (for example with any TTS tool, using your own voice or a stock voice, never someone else's without permission).

pip install librosa numpy

# audio_features.py
import sys
import numpy as np
import librosa

def features(path):
    y, sr = librosa.load(path, sr=16000, mono=True)

    # 1) Spectral roll-off: frequency below which 85% of energy sits
    rolloff = librosa.feature.spectral_rolloff(y=y, sr=sr, roll_percent=0.85).mean()

    # 2) High-frequency energy ratio (above 4 kHz)
    S = np.abs(librosa.stft(y, n_fft=1024)) ** 2
    freqs = librosa.fft_frequencies(sr=sr, n_fft=1024)
    hf_ratio = S[freqs > 4000].sum() / S.sum()

    # 3) Spectral flatness: how "noise-like" vs "tonal" the signal is
    flatness = librosa.feature.spectral_flatness(y=y).mean()

    # 4) Pitch variability (F0 standard deviation in voiced frames)
    f0, voiced, _ = librosa.pyin(y, fmin=65, fmax=400, sr=sr)
    f0_std = np.nanstd(f0[voiced]) if voiced.any() else float("nan")

    # 5) Pause structure: share of near-silent frames
    rms = librosa.feature.rms(y=y)[0]
    silence_ratio = (rms < 0.1 * rms.max()).mean()

    return {
        "rolloff_hz": round(float(rolloff), 1),
        "hf_energy_ratio": round(float(hf_ratio), 4),
        "spectral_flatness": round(float(flatness), 4),
        "f0_std_hz": round(float(f0_std), 1),
        "silence_ratio": round(float(silence_ratio), 3),
    }

if __name__ == "__main__":
    for p in sys.argv[1:]:
        print(p, features(p))

python audio_features.py real_me.wav tts_me.wav

You'll often see differences in high-frequency energy, flatness or pitch variability between the two. But try a few more samples and you'll also notice the problem: the differences aren't consistent. Compression, phone lines, background noise and the specific TTS model all shift these numbers.

That's exactly why hand-picked features gave way to trained models.

From features to a real detector

A production audio deepfake detector typically:

Converts audio to a time-frequency representation (spectrograms, LFCCs or raw waveform)
Feeds it to a neural network trained on large, diverse real and fake datasets
Outputs a score per segment, so you can see where in a call the voice looks synthetic
Is re-trained regularly, because new voice models appear constantly

Even then, accuracy drops on phone-quality audio, heavy compression (WhatsApp voice notes), noisy recordings and voice models it has never seen.

What this means for builders

If you're adding voice verification or fraud checks to an app:

Don't rely on voice alone for authentication. Voice biometrics can be spoofed. Combine with device signals, OTPs or call-back flows.
Use detection as a risk signal, routing suspicious calls or uploads to extra verification, not as an automatic block.
Design for out-of-band checks. The best defence against a cloned "family member" is still a call back to a known number or a pre-agreed code word.

Wrapping up

Audio deepfake detection looks at vocoder artifacts, missing natural noise, prosody and, above all, patterns learned from large datasets. Hand-crafted features are a great way to build intuition, but real-world detection needs trained models, diverse data and humility about error rates.

At ProofAI we currently focus on detecting AI-generated text, documents and images. You can try them free at proofai.in, and the API docs cover integration.

Should we do a follow-up training a small spectrogram classifier on ASVspoof data? Tell us in the comments. 👇

Disclosure: we're the team behind ProofAI at 4Born Solutions. This article was drafted with AI assistance and reviewed and edited by our team. Only clone voices you have permission to use.

Build a Chrome Extension That Checks Selected Text for AI (Manifest V3 Tutorial)

ProofAI | AI Content Detector — Thu, 29 Oct 2026 14:00:00 +0000

Browser extensions are one of the most practical places to put AI detection. You highlight text on any page, right-click, and get a quick read on whether it looks AI-generated, without copying and pasting into another tab.

In this tutorial we'll build a small Manifest V3 Chrome extension that does exactly that. Along the way we'll cover the security mistake most "AI extension" tutorials make: shipping a secret API key inside the extension.

What we're building

A right-click menu item: "Check selected text for AI"
It reads the full selected text from the page
It sends the text to your own backend, which calls the detection API
It shows the result as a Chrome notification

ai-text-checker/
├── manifest.json
├── background.js
└── icon128.png

Why not call the detection API directly from the extension?

Anything inside an extension package can be read by anyone who installs it. Unzip the .crx and your sk_live_... key is right there. So the extension talks to a small backend endpoint you control, and the backend holds the key.

If you followed our earlier post, How to Add AI Content Detection to Your App with a REST API, you already have that endpoint: POST /api/check-text. Any server route that accepts { text } and returns a score will work.

Step 1: manifest.json

{
  "manifest_version": 3,
  "name": "AI Text Checker (demo)",
  "version": "1.0.0",
  "description": "Right-click selected text to check if it looks AI-generated.",
  "permissions": ["contextMenus", "notifications", "activeTab", "scripting"],
  "host_permissions": ["https://yourapp.com/*"],
  "background": { "service_worker": "background.js" },
  "icons": { "128": "icon128.png" }
}

What each permission is for:

contextMenus: adds the right-click item
activeTab + scripting: read the selection from the current tab, only after the user clicks our menu item
notifications: show the result
host_permissions: lets the service worker call your backend without CORS problems

Ask for as little as possible. Reviewers on the Chrome Web Store check this, and so do users.

Step 2: background.js (the service worker)

const BACKEND_URL = "https://yourapp.com/api/check-text";

chrome.runtime.onInstalled.addListener(() => {
  chrome.contextMenus.create({
    id: "check-ai",
    title: "Check selected text for AI",
    contexts: ["selection"],
  });
});

chrome.contextMenus.onClicked.addListener(async (info, tab) => {
  if (info.menuItemId !== "check-ai" || !tab?.id) return;

  // Read the full selection from the page.
  // info.selectionText works too, but reading it from the page is more reliable for long selections.
  let text = info.selectionText ?? "";
  try {
    const [{ result }] = await chrome.scripting.executeScript({
      target: { tabId: tab.id },
      func: () => window.getSelection()?.toString() ?? "",
    });
    if (result) text = result;
  } catch {
    // Some pages (like chrome:// pages) block scripting. Fall back to selectionText.
  }

  const words = text.trim().split(/\s+/).filter(Boolean).length;
  if (words < 50) {
    return notify("Select more text", `Only ${words} words selected. Select at least 50 words for a reliable check.`);
  }

  try {
    const res = await fetch(BACKEND_URL, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ text }),
    });
    const data = await res.json();

    if (data.status === "rate_limited") {
      return notify("Try again later", "The daily check limit was reached.");
    }
    if (data.status !== "ok") {
      return notify("Couldn't check this text", "Please try again in a moment.");
    }

    const labels = {
      high: "High likelihood of AI-generated text",
      medium: "Mixed signals: parts may be AI-generated",
      low: "Low likelihood of AI-generated text",
    };
    notify(labels[data.level], `AI probability: ${data.aiProbability}%. Treat this as one signal, not proof.`);
  } catch (e) {
    console.error(e);
    notify("Network error", "Couldn't reach the checking service.");
  }
});

function notify(title, message) {
  chrome.notifications.create({
    type: "basic",
    iconUrl: "icon128.png",
    title,
    message,
  });
}

A few MV3 details worth knowing:

Service workers aren't persistent. Don't keep state in global variables between clicks. Use chrome.storage if you need it.
Create context menus in onInstalled. Creating them on every service-worker start throws "duplicate id" errors.
chrome.scripting.executeScript returns an array of results, one per frame. We only inject into the main frame here.

Step 3: Load it and test

Open chrome://extensions
Turn on Developer mode
Click Load unpacked and pick the ai-text-checker folder
Select a few paragraphs on any web page, right-click, and choose Check selected text for AI

To debug, click "service worker" on the extension's card to open its DevTools console.

Step 4: Make it production-ready

Before publishing to the Chrome Web Store:

Authenticate users on your backend (for example with a token from your web app), so strangers can't use your quota.
Rate-limit per user on the backend.
Write a clear privacy policy: what text you send, where it goes, and whether it's stored. The Web Store requires disclosures for extensions that handle user data.
Add an options page so users can set their own thresholds or turn notifications off.
Show results in context. A small popup next to the selection, built with a content script, is a nicer experience than a system notification.

Don't want to build it?

If you'd rather not build your own, try the ProofAI Chrome extension, which brings the same detection engine as proofai.in into your browser. Building your own is still a great way to learn MV3, and the pattern works with any detection API.

What would you add to an extension like this: highlighting, history, Google Docs support? Let us know in the comments. 👇

Disclosure: we're the team behind ProofAI at 4Born Solutions. This article was drafted with AI assistance and reviewed and edited by our team.

How to Benchmark an AI Detector on Your Own Data (Precision, Recall and False Positives in Python)

ProofAI | AI Content Detector — Wed, 28 Oct 2026 14:00:00 +0000

Every AI detector claims to be "99% accurate". Those numbers usually come from the vendor's own test set, written in the vendor's favourite style, and they rarely tell you the number that matters most: how often it flags real human writing.

The good news: you can measure a detector on your own data in an afternoon. In this post we'll build a small benchmark in Python that reports precision, recall and false-positive rate, and helps you pick a threshold that fits your use case.

(We build an AI detector, ProofAI, and we'd rather you test us properly than trust a marketing number. The method works for any detector.)

Step 1: Build a labelled test set

This is the part that matters most. You want two folders:

testset/
├── human/   # writing you KNOW is human
└── ai/      # writing you KNOW is AI-generated

Tips for a fair set:

Human samples should look like your real users. If you're a university, use past essays from before 2022 (with permission). If you're in hiring, use old cover letters. Include non-native English writers, because that's where detectors are known to struggle.
AI samples should match the same tasks. Give the same prompts to several models (for example ChatGPT, Gemini and Claude), and include some lightly edited AI text, because that's what you'll see in practice.
Aim for at least 100 of each. Fewer than that and your numbers will swing a lot.
Keep lengths similar. Very short texts are harder to classify, so don't compare 50-word human texts to 800-word AI ones.

Step 2: Score everything

# score_testset.py
import csv, os, time
from pathlib import Path
import requests

API_URL = "https://ai.proofai.in/api/v1/detect"

def detect(text):
    r = requests.post(API_URL,
        headers={"x-api-key": os.environ["PROOFAI_API_KEY"], "Origin": os.environ["PROOFAI_ORIGIN"]},
        data={"content": text}, timeout=30)
    r.raise_for_status()
    return r.json()["ai_probability"]

rows = []
for label in ("human", "ai"):
    for f in sorted(Path("testset", label).glob("*.txt")):
        text = f.read_text(encoding="utf-8")
        rows.append({"file": f.name, "label": 1 if label == "ai" else 0,
                     "words": len(text.split()), "score": detect(text)})
        time.sleep(0.5)

with open("scores.csv", "w", newline="") as fh:
    w = csv.DictWriter(fh, fieldnames=["file", "label", "words", "score"])
    w.writeheader(); w.writerows(rows)

Save the scores once, then experiment with thresholds offline without spending more API calls.

Step 3: Compute the metrics

# evaluate.py
import pandas as pd
from sklearn.metrics import confusion_matrix, roc_auc_score

df = pd.read_csv("scores.csv")

def report(threshold):
    pred = (df.score >= threshold).astype(int)
    tn, fp, fn, tp = confusion_matrix(df.label, pred, labels=[0, 1]).ravel()
    return {
        "threshold": threshold,
        "precision": tp / (tp + fp) if tp + fp else float("nan"),
        "recall": tp / (tp + fn),
        "false_positive_rate": fp / (fp + tn),
        "humans_flagged": f"{fp} of {fp + tn}",
    }

print("ROC AUC:", round(roc_auc_score(df.label, df.score), 3))
print(pd.DataFrame([report(t) for t in (50, 60, 70, 80, 85, 90, 95)]).round(3).to_string(index=False))

Reading the numbers

False-positive rate (FPR): the share of human texts flagged as AI. For education and hiring, this is the number to watch. An FPR of 5% means 1 in 20 honest people gets flagged.
Recall: the share of AI texts the detector catches.
Precision: of everything flagged, how much was actually AI. This depends on how common AI text is in your real data, so don't over-trust it from a 50/50 test set.
ROC AUC: how well scores separate the two groups across all thresholds (1.0 is perfect, 0.5 is random).

Step 4: Choose a threshold for your risk

There's no universal "right" threshold. Decide which mistake is worse for you:

Use case	Worse mistake	Pick a threshold that...
Student essays, hiring	Flagging a real person	keeps FPR very low (for example ≤1–2%), even if recall drops
Spam / content farm filtering	Letting junk through	keeps recall high, with human review on flags
Editorial quality checks	Neither is serious	sits in the middle; treat as a writing hint

Step 5: Slice the results

Overall numbers hide problems. Break them down:

df["length_bucket"] = pd.cut(df.words, [0, 150, 300, 600, 10_000])
for bucket, g in df.groupby("length_bucket", observed=True):
    human = g[g.label == 0]
    if len(human):
        print(bucket, "FPR at 85:", round((human.score >= 85).mean(), 3), f"(n={len(human)})")

Do the same by writer group (native vs non-native English), topic and AI model. If one group's false-positive rate is much higher, you've found where human review is essential.

Common mistakes

Testing on texts the vendor might have trained on, like famous essays or public datasets. Use your own data.
Only testing raw AI output. Real users edit, paraphrase and mix. Include those.
Reporting one accuracy number. Always report FPR separately.
Re-testing never. Models change. Re-run your benchmark every few months.

Wrapping up

With two folders of labelled text and about 60 lines of Python, you can replace "99% accurate" marketing with numbers that reflect your users, your tasks and your risk tolerance. Whatever detector you choose, publish your threshold and review process internally, so decisions stay consistent and fair.

Try ProofAI's free detector or the API in your own benchmark. We'd genuinely like to hear the results.

Have you benchmarked an AI detector? What false-positive rate did you see? Share in the comments. 👇

Disclosure: we're the team behind ProofAI at 4Born Solutions. This article was drafted with AI assistance and reviewed and edited by our team.

How AI Image Detection Works: Artifacts, Frequency Analysis and C2PA

ProofAI | AI Content Detector — Mon, 26 Oct 2026 14:00:00 +0000

"Is this image real?" used to be a question for photo editors. Now it's a question for every platform that accepts uploads, from marketplaces and dating apps to newsrooms and KYC flows.

In this post we'll look at how AI image detection works in practice: the pixel and frequency artifacts that classifiers learn, the provenance metadata standards like C2PA, and invisible watermarks like Google's SynthID. We'll also run two small experiments you can try on your own machine.

Three ways to answer "was this made by AI?"

Approach	What it looks at	Strength	Weakness
Artifact detection	The pixels themselves	Works on any image	Probabilistic; can be fooled by resizing, compression and new models
Provenance metadata (C2PA)	Signed "Content Credentials" attached to the file	Strong, cryptographically signed evidence when present	Easily lost by screenshots and re-encoding
Watermarks (e.g. SynthID)	An invisible signal embedded at generation time	Survives some editing	Only works for models that add it, and needs the vendor's detector

Real-world systems combine all three.

1. Artifact detection: what classifiers learn

Image generators like diffusion models build pictures in ways that leave statistical traces:

Frequency-domain patterns. Upsampling layers in generators can leave periodic, grid-like signals that are hard to see but show up clearly in a Fourier transform.
Noise inconsistencies. Camera photos carry sensor noise that's consistent across the frame. Generated images often have noise that's too smooth or inconsistent between regions.
Semantic slips. Hands, text inside images, reflections, jewellery, earrings that don't match, and shadows pointing in different directions.

Modern detectors are usually deep classifiers (CNNs or vision transformers) trained on large sets of real and generated images. They learn these cues automatically rather than relying on hand-written rules.

Experiment: look at an image's frequency spectrum

This won't detect AI on its own, but it shows the kind of signal detectors use. You need numpy, pillow and matplotlib.

# pip install numpy pillow matplotlib
import numpy as np
from PIL import Image
import matplotlib.pyplot as plt

def log_spectrum(path: str) -> np.ndarray:
    img = np.asarray(Image.open(path).convert("L"), dtype=np.float32)
    f = np.fft.fftshift(np.fft.fft2(img))
    return np.log1p(np.abs(f))

def radial_profile(spec: np.ndarray) -> np.ndarray:
    h, w = spec.shape
    y, x = np.indices(spec.shape)
    r = np.hypot(x - w // 2, y - h // 2).astype(int)
    totals = np.bincount(r.ravel(), spec.ravel())
    counts = np.bincount(r.ravel())
    return totals / np.maximum(counts, 1)

for path in ["real_photo.jpg", "generated.png"]:
    spec = log_spectrum(path)
    plt.figure()
    plt.title(path)
    plt.imshow(spec, cmap="gray")
    plt.figure(99)
    plt.plot(radial_profile(spec), label=path)

plt.figure(99)
plt.xlabel("Frequency (radius)")
plt.ylabel("Log magnitude")
plt.legend()
plt.show()

Compare a photo from your phone with an AI-generated image. You'll sometimes see bright dots or grid patterns in the generated image's spectrum, or a different fall-off curve at high frequencies. You'll also see how much JPEG compression and resizing muddy the picture, which is why production detectors need a lot more than one hand-made feature.

2. Provenance: C2PA Content Credentials

The C2PA standard (Coalition for Content Provenance and Authenticity) lets cameras, editing apps and AI generators attach a cryptographically signed manifest to a file. It records who or what created the image and what edits were made.

Adoption has picked up a lot in 2026. At Google I/O in May 2026, Google said C2PA verification and SynthID detection are coming to Search and Chrome, and OpenAI announced it would add SynthID watermarks to its images alongside existing C2PA credentials.

Experiment: read Content Credentials from a file

The open-source c2patool from the Content Authenticity Initiative can print a file's manifest:

# Install (requires Rust's cargo), or download a release binary from GitHub
cargo install c2patool

# Print the C2PA manifest, if the file has one
c2patool some_image.jpg

If the file carries credentials, you'll get JSON describing the claim generator, signature and actions such as "created by an AI model" or "edited". If it doesn't, the tool reports that no manifest was found.

Key rule for developers: a missing manifest proves nothing. Screenshots, re-uploads and many social platforms strip metadata. Treat "no credentials" as inconclusive, not as "real" or "fake".

3. Watermarks: SynthID and friends

Watermarking works differently: the generator embeds an invisible signal into the pixels (or audio, or text) at creation time. Google DeepMind's SynthID is the best-known example. Google DeepMind reported in May 2026 that more than 100 billion images, videos and audio files have been watermarked with it.

Limitations to keep in mind:

A watermark only exists if the generating model added one. Images from open-source models running locally usually won't have one.
Checking a watermark depends on the vendor's detector.
A watermark says "this came from model X", not who made it or why.

Putting it together in a product

A sensible pipeline for user-uploaded images looks like this:

Check provenance first. If valid C2PA credentials say "AI-generated", you have strong evidence.
Check known watermarks where tools are available.
Run an artifact classifier for everything else, and treat its output as a probability.
Route uncertain or high-risk cases to a human, especially for KYC, news and legal contexts.
Ask for originals when stakes are high. A real photographer usually has the RAW file or the original from their phone.

Where ProofAI fits

ProofAI checks images for signs of AI generation and manipulation using computer-vision analysis, alongside text and document detection. AI video and deepfake detection is coming soon; for now, you can check key frames from a video as images. Like every detector, it returns a confidence score, not a verdict.

What's the most convincing AI image you've seen this year, and what gave it away? Share in the comments. 👇

Disclosure: we're the team behind ProofAI at 4Born Solutions. This article was drafted with AI assistance and reviewed and edited by our team.

Can Turnitin Detect AI in a PDF? What Students Should Know

ProofAI | AI Content Detector — Sun, 25 Oct 2026 02:21:05 +0000

Short answer: yes. Turnitin treats a PDF the same way as a Word file. If the PDF contains enough readable, long-form text in a supported language, it goes through the same AI writing check as a .docx. Saving your assignment as a PDF does not hide anything from it, and it does not make a human-written essay look more or less "AI".

What matters is not the file type but what is inside the file: how many words, what kind of writing, which language, and whether the text can actually be read. This guide explains each of those, what you will (and will not) see as a student, and how to check your own file before you submit.

How Turnitin's AI check handles PDFs

Turnitin publishes the conditions a submission has to meet before it gets an AI writing report. According to its guide File requirements for an AI writing report, a file needs:

At least 300 words and no more than 30,000 words of prose.
Long-form writing, the kind you find in essays, reports and theses.
An accepted file type: .docx, .pdf, .txt or .rtf.
A file under 100 MB.
A supported language: English, Spanish or Japanese.

There is no separate route for PDFs. A PDF that meets these rules is checked like any other file. A PDF that does not meet them simply does not get an AI score.

What can stop a PDF from getting an AI score

Most "Turnitin did not detect anything in my PDF" stories come down to one of these:

The PDF is a scan. If you photographed or scanned printed pages, the PDF is a picture of text, not text. A checker that reads words has nothing to read unless the file has a text layer. A quick test: open the PDF and try to select a sentence with your cursor. If you can't, the text is an image.
The text is too short. Under 300 words of prose, there is no AI writing report at all.
The writing is not long-form prose. Bullet-point notes, tables, code, poems and scripts are not the format the check is built for. Many university guides warn that these get unreliable results or none.
The language is not supported. A Hindi or Marathi assignment does not get an AI writing report from Turnitin today. Mixed-language files can behave unpredictably.

None of these are tricks to "beat" Turnitin. Your instructor still sees the file, reads it, and can ask you about it. They are simply the reasons a report may be missing.

Can students see their Turnitin AI score?

Usually not. In most institutions the AI writing indicator and report are visible to instructors and administrators only. University help pages such as the University of Melbourne's guide and Longwood University's announcement say students do not see the AI result, even when they can see their similarity (plagiarism) score. Turnitin's own help article Why can't I see the AI writing detection report? explains the account and file conditions behind a missing report.

That is why many students want to check their work before they submit: once it is in Turnitin, you usually cannot see what the AI indicator says.

How to check your own PDF before you submit

You cannot run Turnitin's AI check yourself, but you can see how an AI detector reads your text and fix problems early:

Make sure the text is selectable. If you exported from Word or Google Docs, it is. If you scanned pages, export the original document again instead.
Count your words. Under 300 words, there will be no AI writing report in Turnitin anyway.
Run the file through a detector. With the ProofAI document detector you can upload a PDF, DOCX, DOC or TXT file directly, without copy-pasting, and see an AI probability in seconds. It is free for a few checks a day.
Read the result as a signal, not a verdict. If a section of your own writing looks "AI-like", look at why: very generic phrasing, repeated sentence patterns, or text you rewrote with a paraphrasing tool.
Keep your drafts. Version history in Google Docs or Word, notes and outlines are the best evidence that the work is yours if a question ever comes up.

The honest limits of every AI detector

No AI detector, Turnitin or ProofAI included, can prove who wrote a text. They estimate how likely it is that text was generated, based on patterns. Human writing can be flagged, especially very formal, formulaic or non-native English writing, and edited AI text can be missed. We explain why in AI detector false positives: why human writing gets flagged.

So a score should start a conversation, not end one. If you are a student and a report surprises you, ask your instructor what they saw and share your drafts. If you are an instructor, look at the writing itself and talk to the student before drawing conclusions.

Turnitin vs a self-check: when to use which

Turnitin is sold to institutions, not individuals, so students in India and elsewhere normally meet it only through their college's submission portal. A self-check tool is for the step before that: making sure your file is readable, your text is your own, and nothing looks unexpected. We compare the two in more detail in our Turnitin alternative guide for India.

FAQ

Does converting Word to PDF hide AI writing from Turnitin?
No. A text-based PDF is checked the same way as the Word file it came from. The format does not change what the text says.

Can Turnitin detect AI in a scanned PDF?
A scan with no text layer has no text for an AI writing check to read, so it may get no AI score. Your instructor can still read it and may ask for an editable version, so submitting a scan is not a safe way around anything.

How many words does Turnitin need to check for AI?
At least 300 words of long-form prose, and no more than 30,000, according to Turnitin's published file requirements.

Does Turnitin's AI check work for Hindi?
Not at the moment. Turnitin lists English, Spanish and Japanese as the supported languages for AI writing detection.

Can I see my Turnitin AI score as a student?
In most institutions, no. The AI indicator is usually visible only to instructors and administrators.

The bottom line

Turnitin can detect AI writing in a PDF just as it can in a Word file, as long as the PDF has enough readable prose in a supported language. File format is not a loophole. If you want peace of mind before a deadline, export a clean, text-based PDF, keep your drafts, and run a quick self-check with a document AI detector first.

Originally published on ProofAI.

Build a Discord Bot That Checks Messages for AI-Generated Text (discord.js v14)

ProofAI | AI Content Detector — Sat, 24 Oct 2026 14:00:00 +0000

Community managers are seeing more AI-generated posts: bot-like "introductions", copy-pasted answers in help channels, and contest entries that read suspiciously polished.

In this tutorial we'll build a small Discord bot with discord.js v14 that lets moderators right-click any message and choose "Check for AI". The bot replies privately (only the moderator sees it) with an AI-likelihood score.

We deliberately don't auto-scan every message or auto-delete anything. More on why at the end.

What you'll need

Node.js 20.6+ (for the built-in --env-file flag)
A Discord application and bot token from the Developer Portal
An AI detection API key (we use ProofAI's, but any detector with a probability score works)

mkdir ai-check-bot && cd ai-check-bot
npm init -y
npm pkg set type=module   # we use ES modules and top-level await
npm install discord.js

# .env (never commit this)
DISCORD_TOKEN=your-bot-token
DISCORD_CLIENT_ID=your-application-id
PROOFAI_API_KEY=sk_live_...
PROOFAI_ORIGIN=https://yourapp.com

Step 1: Register a message context-menu command

Context-menu commands appear when you right-click a message → Apps. No slash command typing, and no need for the privileged Message Content intent, because Discord passes the target message to your bot when a moderator uses the command.

// register.js
import { REST, Routes, ContextMenuCommandBuilder, ApplicationCommandType, PermissionFlagsBits } from "discord.js";

const command = new ContextMenuCommandBuilder()
  .setName("Check for AI")
  .setType(ApplicationCommandType.Message)
  .setDefaultMemberPermissions(PermissionFlagsBits.ManageMessages); // moderators only by default

const rest = new REST().setToken(process.env.DISCORD_TOKEN);
await rest.put(Routes.applicationCommands(process.env.DISCORD_CLIENT_ID), { body: [command.toJSON()] });
console.log("Registered 'Check for AI'");

Run it once:

node --env-file=.env register.js

Step 2: The detection helper

// detect.js
const API_URL = "https://ai.proofai.in/api/v1/detect";

export async function detectAI(text) {
  const words = text.trim().split(/\s+/).filter(Boolean).length;
  if (words < 50) return { status: "too_short", words };

  const res = await fetch(API_URL, {
    method: "POST",
    headers: {
      "x-api-key": process.env.PROOFAI_API_KEY,
      "Origin": process.env.PROOFAI_ORIGIN,
      "Content-Type": "application/x-www-form-urlencoded",
    },
    body: new URLSearchParams({ content: text }),
  });

  if (res.status === 429) return { status: "rate_limited" };
  if (!res.ok) return { status: "error" };
  const data = await res.json();
  return { status: "ok", p: data.ai_probability };
}

Short Discord messages ("lol same", "thanks!") can't be scored meaningfully, so we refuse anything under 50 words instead of returning a misleading number.

Step 3: The bot

// bot.js
import { Client, Events, GatewayIntentBits, MessageFlags } from "discord.js";
import { detectAI } from "./detect.js";

const client = new Client({ intents: [GatewayIntentBits.Guilds] });

client.once(Events.ClientReady, (c) => console.log(`Logged in as ${c.user.tag}`));

client.on(Events.InteractionCreate, async (interaction) => {
  if (!interaction.isMessageContextMenuCommand()) return;
  if (interaction.commandName !== "Check for AI") return;

  // Detection can take a few seconds, so acknowledge first (privately)
  await interaction.deferReply({ flags: MessageFlags.Ephemeral });

  const text = interaction.targetMessage.content ?? "";
  const result = await detectAI(text);

  let reply;
  if (result.status === "too_short") {
    reply = `This message has only ${result.words} words. Detection needs at least 50 words to be meaningful.`;
  } else if (result.status === "rate_limited") {
    reply = "Daily detection limit reached. Try again later.";
  } else if (result.status !== "ok") {
    reply = "Couldn't check this message right now.";
  } else {
    const level = result.p >= 85 ? "High" : result.p >= 60 ? "Medium" : "Low";
    reply = `**${level} likelihood of AI-generated text** (${result.p}%).\n` +
            `Treat this as one signal, not proof. Talk to the member before taking action.`;
  }

  await interaction.editReply(reply);
});

client.login(process.env.DISCORD_TOKEN);

node --env-file=.env bot.js

Invite the bot with the applications.commands and bot scopes, then right-click a long message → Apps → Check for AI.

Why the reply is ephemeral

MessageFlags.Ephemeral means only the moderator who ran the command sees the result. Posting "this person used AI!" publicly, based on a probability, is a fast way to embarrass a real member and lose trust in your mod team.

Things we deliberately didn't build

Auto-scanning every message. It needs the privileged Message Content intent, burns your API quota on small talk, and creates a feeling of surveillance.
Auto-delete or auto-ban. Detectors make mistakes. False positives are more common for non-native English writers and very formal writing.
Public "AI" badges. Same reason.

Good uses: checking contest submissions, long "introductions" from brand-new accounts that look spammy, or answers copy-pasted into help channels.

Ideas to extend it

Log checks to a private #mod-log channel for transparency within the mod team
Add a per-moderator cooldown so nobody burns the quota
Support attachments (PDF/DOCX) using the extraction code from our batch-scanning post

Full API reference: ProofAI API docs · Try the free web detector.

Do you moderate a community? How are you handling AI-generated posts? Tell us in the comments. 👇

Disclosure: we're the team behind ProofAI at 4Born Solutions. This article was drafted with AI assistance and reviewed and edited by our team.

Designing a Fair AI Detection Feature: 7 UX Patterns That Prevent False Accusations

ProofAI | AI Content Detector — Thu, 22 Oct 2026 14:00:00 +0000

Adding an AI detector to your product takes an afternoon. Designing it so it doesn't falsely accuse a real person takes much more thought.

A student who gets flagged for an essay they wrote, or a candidate rejected because a tool said "AI", is a real harm. It's also a support ticket, a trust problem and, increasingly, a compliance risk. This post collects UX and product patterns we recommend for any feature that uses an AI detection score, whichever provider you use.

Why this matters: false positives are real

In 2023, Stanford researchers (Liang et al., "GPT detectors are biased against non-native English writers") tested seven popular detectors on 91 TOEFL essays written by non-native English speakers. On average, the detectors misclassified 61.3% of those human-written essays as AI-generated, and almost all of the essays were flagged by at least one detector.
OpenAI withdrew its own AI text classifier in July 2023, citing its low rate of accuracy.
Formal, simple or heavily edited human writing can look statistically "predictable", which is exactly what detectors look for.

None of this means detection is useless. It means the interface around the score decides whether the feature is helpful or harmful.

Pattern 1: Show confidence levels, not verdicts

❌ AI-GENERATED in a red badge

✅ High likelihood of AI-generated text (review recommended)

A raw number like "87%" also misleads, because people read it as "87% of this was written by AI" or "87% chance this person cheated". Neither is true. Map the score into a few bands:

function presentScore(aiProbability) {
  if (aiProbability >= 85) {
    return { label: "High likelihood of AI", tone: "warning", action: "review" };
  }
  if (aiProbability >= 60) {
    return { label: "Mixed signals", tone: "neutral", action: "optional_review" };
  }
  return { label: "Low likelihood of AI", tone: "info", action: "none" };
}

Tune the thresholds for your use case. A plagiarism-sensitive exam needs different bands from a blog moderation queue.

Pattern 2: Refuse to score short text

Short texts don't carry enough statistical signal. ProofAI's API docs recommend at least 50 words, and many teams set a higher bar for high-stakes decisions.

const MIN_WORDS = 50;
if (wordCount(text) < MIN_WORDS) {
  return ui.show("Not enough text to analyze reliably. Add at least 50 words.");
}

Showing "not enough text" is honest. Showing a confident score on two sentences is not.

Pattern 3: Highlight passages, don't stamp documents

Most real documents are mixed. Someone might write the body themselves and use AI to polish the intro. If your provider returns per-segment scores (ProofAI's API returns a segments array), highlight passages instead of labelling the whole file:

function renderSegments(segments) {
  return segments.map(s => `
    <span class="seg seg--${s.color_label}" title="AI likelihood: ${s.ai_prob}%">
      ${escapeHtml(s.text)}
    </span>`).join("");
}

Reviewers can then ask a precise question ("Can you walk me through how you wrote this section?") instead of making a blanket accusation.

Pattern 4: Humans decide, the tool informs

Never wire a detection score directly into an automatic, high-impact action:

❌ Auto-reject applications above 80%
❌ Auto-fail assignments above a threshold
✅ Add a "needs review" flag and send the item to a person
✅ Combine the score with other evidence: drafts, version history, a short conversation, timed in-class writing

Log who reviewed each flagged item and what they decided. That audit trail protects both your users and your company.

Pattern 5: Explain it in the UI

A small "How is this calculated?" link does a lot of work. Say plainly:

What the score measures (statistical patterns common in AI-generated text)
What it doesn't prove (authorship or intent)
That results can be wrong, especially for short texts and non-native writing
How a person can appeal or add context

Pattern 6: Give people a way to respond

If you show a flag to the person who wrote the content, such as a student or candidate, give them a clear path:

See which passages were flagged
Add context or upload drafts
Request human review

An appeal button costs little to build and prevents a lot of harm.

Pattern 7: Be careful with privacy

Detection means sending user content to a third party. Check:

Does the provider store submitted content or use it for training? (ProofAI states it doesn't store scanned content.)
Is the connection encrypted, and are API keys restricted to your domain?
Do your terms tell users their content may be checked?

Under rules like the EU AI Act's transparency obligations (applying from 2 August 2026) and India's amended IT Rules on synthetically generated content (in force since 20 February 2026), how you handle AI-related content is getting more regulatory attention. Being transparent with users is the safest default.

A quick checklist

[ ] Scores shown as confidence bands, not verdicts
[ ] Minimum length enforced
[ ] Passage-level highlighting where possible
[ ] No automatic high-impact decisions
[ ] "How this works" explanation in the UI
[ ] Appeal or "add context" path
[ ] Privacy and data-retention checked

Wrapping up

The detection model is only half the feature. The other half is the interface that decides how people act on it. If you get these patterns right, AI detection becomes a helpful review signal instead of a source of false accusations.

If you want to try these patterns with real scores, the ProofAI free detector works without login, and our API docs show the segment-level response format.

Have you ever been falsely flagged by an AI detector, or had to handle a complaint about one? We'd like to hear how it went in the comments. 👇

Disclosure: we're the team behind ProofAI at 4Born Solutions. This article was drafted with AI assistance and reviewed and edited by our team.

Batch-Scan PDFs and Word Files for AI-Generated Text with Python

ProofAI | AI Content Detector — Wed, 21 Oct 2026 14:00:00 +0000

Teachers get a folder of 60 essays. HR gets a shared drive of cover letters. Editors get a pile of freelancer drafts. Checking each one by copy-pasting into a web tool doesn't scale.

In this tutorial we'll build a small Python script that:

Walks a folder of PDF, DOCX and TXT files
Extracts the text from each one
Sends it to an AI detection API, with rate limiting and retries
Writes a CSV report with the score and the passages that drove it

The examples use the ProofAI API (it's what we build), but the structure works with any detection provider that returns a probability.

Setup

pip install pypdf python-docx requests

Keep your API key out of the code:

export PROOFAI_API_KEY="sk_live_..."
export PROOFAI_ORIGIN="https://yourapp.com"

Step 1: Extract text from any file

# extract.py
from pathlib import Path
from pypdf import PdfReader
import docx

def extract_text(path: Path) -> str:
    suffix = path.suffix.lower()
    if suffix == ".pdf":
        reader = PdfReader(str(path))
        return "\n".join((page.extract_text() or "") for page in reader.pages)
    if suffix == ".docx":
        d = docx.Document(str(path))
        return "\n".join(p.text for p in d.paragraphs)
    if suffix in {".txt", ".md"}:
        return path.read_text(encoding="utf-8", errors="ignore")
    raise ValueError(f"Unsupported file type: {suffix}")

Two gotchas worth handling:

Scanned PDFs return almost no text, because the pages are images. Flag them for manual review (or OCR them first) instead of scoring an empty string.
Headers, footers and reference lists add noise. For essays, consider dropping everything after a "References" or "Bibliography" heading before scoring.

Step 2: Call the detector with retries

# detect.py
import os, time, requests

API_URL = "https://ai.proofai.in/api/v1/detect"

def detect(text: str, max_retries: int = 3) -> dict:
    for attempt in range(max_retries):
        resp = requests.post(
            API_URL,
            headers={
                "x-api-key": os.environ["PROOFAI_API_KEY"],
                "Origin": os.environ["PROOFAI_ORIGIN"],
            },
            data={"content": text},
            timeout=30,
        )
        if resp.status_code == 429:           # rate limited: back off and retry
            time.sleep(2 ** attempt * 2)
            continue
        if resp.status_code >= 500:           # server hiccup: retry once or twice
            time.sleep(2)
            continue
        resp.raise_for_status()
        return resp.json()
    raise RuntimeError("Detection failed after retries")

Exponential backoff on 429 is the difference between a script that finishes and one that dies halfway through a folder of 200 files.

Step 3: Score long documents in chunks

A 3,000-word report is better scored in chunks than as one blob: you get a per-section picture, and one AI-written section doesn't get averaged away.

# chunking.py
def chunks(text: str, size: int = 400):
    words = text.split()
    for i in range(0, len(words), size):
        piece = words[i:i + size]
        if len(piece) >= 50:                  # skip fragments too short to score well
            yield " ".join(piece)

Step 4: Put it together and write a CSV

# scan_folder.py
import csv, sys, time
from pathlib import Path
from extract import extract_text
from detect import detect
from chunking import chunks   # the chunks() function above

SUPPORTED = {".pdf", ".docx", ".txt", ".md"}

def scan(folder: str, out_csv: str = "ai_report.csv"):
    rows = []
    for path in sorted(Path(folder).rglob("*")):
        if path.suffix.lower() not in SUPPORTED:
            continue
        try:
            text = extract_text(path)
        except Exception as e:
            rows.append({"file": path.name, "status": f"error: {e}"})
            continue

        words = len(text.split())
        if words < 50:
            rows.append({"file": path.name, "words": words, "status": "too_short_or_scanned"})
            continue

        scores, top = [], []
        for piece in chunks(text):
            result = detect(piece)
            scores.append(result["ai_probability"])
            top += sorted(result.get("segments", []), key=lambda s: s["ai_prob"], reverse=True)[:1]
            time.sleep(0.5)                   # be gentle with rate limits

        rows.append({
            "file": path.name,
            "words": words,
            "chunks": len(scores),
            "max_ai_probability": max(scores),
            "avg_ai_probability": round(sum(scores) / len(scores), 1),
            "highest_passage": (max(top, key=lambda s: s["ai_prob"])["text"][:150] if top else ""),
            "status": "ok",
        })

    fields = ["file", "words", "chunks", "max_ai_probability", "avg_ai_probability", "highest_passage", "status"]
    with open(out_csv, "w", newline="", encoding="utf-8") as f:
        w = csv.DictWriter(f, fieldnames=fields)
        w.writeheader()
        w.writerows(rows)
    print(f"Scanned {len(rows)} files -> {out_csv}")

if __name__ == "__main__":
    scan(sys.argv[1] if len(sys.argv) > 1 else "./documents")

Run it:

python scan_folder.py ./submissions

You'll get a spreadsheet you can sort by max_ai_probability, with the single passage that scored highest for each file.

Why both max and average?

Average tells you how the document reads overall.
Max catches the case where one section (an introduction, a conclusion, a "research summary") was pasted in from an AI tool.

Show reviewers both, plus the passage, so they're looking at evidence rather than a single number.

Using the report responsibly

A batch report makes it tempting to sort and act. Please don't do that blindly:

Treat scores as a reason to look closer, not a verdict. Detectors produce false positives, and studies (for example Liang et al., Stanford, 2023) have shown higher false-positive rates for non-native English writers.
Talk to the person. Ask about their process, drafts or version history before any decision.
Store reports securely. You're processing other people's writing. Delete what you don't need.

Wrapping up

In about 100 lines of Python you have a folder scanner for PDFs, Word files and text, with chunking, retries and a reviewer-friendly CSV. Next steps could be a simple web upload page, OCR for scanned files, or a nightly job on a shared drive.

Full API reference: ProofAI API docs. You can also try the free web detector first (no login needed).

What would you add: OCR, a Google Drive connector, or a Slack summary? Let us know in the comments. 👇

Disclosure: we're the team behind ProofAI at 4Born Solutions. This article was drafted with AI assistance and reviewed and edited by our team.

How to Add AI Content Detection to Your App with a REST API (Node.js + Python)

ProofAI | AI Content Detector — Mon, 19 Oct 2026 14:00:00 +0000

If your app accepts essays, job applications, reviews, blog posts or support tickets, someone on your team has probably asked: "Can we tell if this was written by AI?"

In this tutorial we'll add AI content detection to an app using a REST API, with working Node.js and Python examples. We'll also cover the parts most tutorials skip: minimum input length, error handling, keeping your API key safe and showing results responsibly.

We'll use the ProofAI API because it's what we build, but the patterns apply to any detection provider.

What you'll build

A small server-side helper that:

Takes a piece of text
Checks it's long enough to score reliably
Sends it to the detection API
Returns a confidence level that your UI can show safely

Step 1: Get an API key and know the request shape

ProofAI authenticates with two headers:

Header	What it is
`x-api-key`	Your secret key (starts with `sk_live_...`)
`Origin`	The domain registered for that key

The detect endpoint is:

POST https://ai.proofai.in/api/v1/detect
Content-Type: application/x-www-form-urlencoded

content=<the text to analyze>

A successful response looks like this:

{
  "ai_probability": 85,
  "human_probability": 15,
  "final_probability": 85,
  "verdict": "Likely AI",
  "input_type": "text",
  "model_version": "v1.0",
  "segments": [
    { "text": "...", "ai_prob": 85, "human_prob": 15, "color_label": "red", "is_data": true }
  ]
}

The segments array is useful: it lets you highlight which parts of a document look AI-generated instead of labelling the whole thing.

Step 2: Keep the key on the server

Never call a detection API with a secret key directly from browser JavaScript or a mobile app bundle. Anyone can open DevTools and copy it. Put the call behind your own backend endpoint and keep the key in an environment variable:

# .env
PROOFAI_API_KEY=sk_live_your_key_here
PROOFAI_ORIGIN=https://yourapp.com

Step 3: Node.js (18+) example

Node 18+ ships with fetch, so there's nothing to install.

// detect.js
const API_URL = "https://ai.proofai.in/api/v1/detect";
const MIN_WORDS = 50; // the API docs recommend at least 50 words

export async function detectAI(text) {
  const words = text.trim().split(/\s+/).filter(Boolean).length;
  if (words < MIN_WORDS) {
    return { status: "too_short", words, minWords: MIN_WORDS };
  }

  const res = await fetch(API_URL, {
    method: "POST",
    headers: {
      "x-api-key": process.env.PROOFAI_API_KEY,
      "Origin": process.env.PROOFAI_ORIGIN,
      "Content-Type": "application/x-www-form-urlencoded",
    },
    body: new URLSearchParams({ content: text }),
  });

  if (res.status === 429) {
    return { status: "rate_limited" }; // quota hit: retry later or queue it
  }
  if (!res.ok) {
    const err = await res.text();
    throw new Error(`Detection failed (${res.status}): ${err}`);
  }

  const data = await res.json();
  return {
    status: "ok",
    aiProbability: data.ai_probability,
    level: toConfidenceLevel(data.ai_probability),
    segments: data.segments ?? [],
  };
}

function toConfidenceLevel(p) {
  if (p >= 85) return "high";
  if (p >= 60) return "medium";
  return "low";
}

And a minimal Express route that your frontend calls:

// server.js
import express from "express";
import { detectAI } from "./detect.js";

const app = express();
app.use(express.json({ limit: "200kb" }));

app.post("/api/check-text", async (req, res) => {
  try {
    const result = await detectAI(String(req.body.text ?? ""));
    res.json(result);
  } catch (e) {
    console.error(e);
    res.status(502).json({ status: "error" });
  }
});

app.listen(3000, () => console.log("Listening on :3000"));

Step 4: Python example

# detect.py
import os
import requests

API_URL = "https://ai.proofai.in/api/v1/detect"
MIN_WORDS = 50

def detect_ai(text: str) -> dict:
    words = len(text.split())
    if words < MIN_WORDS:
        return {"status": "too_short", "words": words, "min_words": MIN_WORDS}

    resp = requests.post(
        API_URL,
        headers={
            "x-api-key": os.environ["PROOFAI_API_KEY"],
            "Origin": os.environ["PROOFAI_ORIGIN"],
        },
        data={"content": text},  # requests sends this as form-urlencoded
        timeout=15,
    )

    if resp.status_code == 429:
        return {"status": "rate_limited"}
    resp.raise_for_status()

    data = resp.json()
    p = data["ai_probability"]
    level = "high" if p >= 85 else "medium" if p >= 60 else "low"
    return {"status": "ok", "ai_probability": p, "level": level,
            "segments": data.get("segments", [])}

Step 5: Handle errors like a production feature

The API uses standard HTTP codes. Map each one to a clear behaviour:

Code	Meaning	What your app should do
200	Success	Show the result
400	Bad input	Show "couldn't analyze this text"
401	Bad key or Origin mismatch	Alert your team; check env vars
429	Quota or rate limit	Queue and retry with backoff
5xx	Server issue	Retry once, then show "try again later"

For bulk jobs (for example, scanning every application submitted today), use a queue with a concurrency limit instead of firing hundreds of requests at once.

Step 6: Show results responsibly

This is the most important step, and it's a product decision rather than a code one.

AI detection is probabilistic. Research has shown real false positives. A 2023 Stanford study by Liang et al. found that popular GPT detectors flagged a majority of essays written by non-native English speakers as AI-generated. So:

Show a confidence level ("high / medium / low likelihood of AI"), not a hard "AI" or "Human" stamp.
Use the segments to highlight specific passages so reviewers can see why.
Never auto-reject. Route high scores to a human reviewer.
Tell users how the score is used in your terms or UI.

We'll go deeper on this UX side in the next post in this series.

Wrapping up

You now have a server-side detection helper in Node.js and Python, with input validation, error handling and a safe way to present results. From here you can add caching for repeated texts, batch processing or a review dashboard.

📚 Full reference: ProofAI API documentation
🔑 Try the detector free first (no login, 10 scans a day): proofai.in

Question for you: where would AI detection actually help in your product? Submissions, reviews, moderation or something else? Tell us in the comments. 👇

Disclosure: we're the team behind ProofAI at 4Born Solutions. This article was drafted with AI assistance and reviewed and edited by our team.