Package Exports

ai-text-detector

Readme

AI Text Detector

A lightweight, fast JavaScript/TypeScript library for detecting AI-generated text using advanced linguistic analysis. Features enhanced human text recognition, modern AI pattern detection, and adaptive thresholding. Works in both Node.js and browser environments with zero dependencies.

🎯 Try the Live Demo

Features

🚀 Lightweight - Zero external dependencies, small bundle size
🔍 Accurate - Uses 25+ linguistic analysis techniques including advanced perplexity and burstiness
🌐 Universal - Works in Node.js, React, Vue, Angular, and browser environments
📝 TypeScript - Full TypeScript support with comprehensive type definitions
⚡ Fast - Efficient pattern matching and analysis algorithms
🧠 Smart - Advanced analysis of sentence structure, vocabulary patterns, and writing style
📊 Detailed - Provides confidence scores, reasoning, and detailed metrics
🎯 Enhanced Human Detection - Improved recognition of informal, casual, and emotional human writing
🔬 Advanced AI Pattern Recognition - Detects modern AI writing patterns and phrases
🏷️ Adaptive Analysis - Dynamic thresholding based on text characteristics

Installation

npm install ai-text-detector

yarn add ai-text-detector

Usage

Basic Usage

import {
  detectAIText,
  isAIGenerated,
  getConfidenceScore,
} from "ai-text-detector";

const longText =
  "Furthermore, it is important to note that artificial intelligence has significantly enhanced various operational processes across multiple industries.";

const shortText = "Hello world!";

// Get detailed analysis for longer text
const result = detectAIText(longText);
console.log(result);
// {
//   isAIGenerated: true,
//   confidence: 0.75,
//   reasons: [
//     "High frequency of transition words typical of AI writing",
//     "Elevated formality level characteristic of AI text"
//   ],
//   score: 0.75
// }

// Handle short text (less than 50 characters)
try {
  const shortResult = detectAIText(shortText);
  console.log(shortResult);
} catch (error) {
  console.log("Error:", error.message);
  // Output: "Error: Text too short for reliable analysis (minimum 50 characters)"
}

// Alternative: Check text length before analysis
function safeDetectAI(text) {
  if (text.trim().length < 50) {
    return {
      isAIGenerated: false,
      confidence: 0,
      reasons: ["Text too short for reliable analysis"],
      score: 0,
      error: "Minimum 50 characters required",
    };
  }
  return detectAIText(text);
}

const safeResult = safeDetectAI(shortText);
console.log(safeResult);
// {
//   isAIGenerated: false,
//   confidence: 0,
//   reasons: ["Text too short for reliable analysis"],
//   score: 0,
//   error: "Minimum 50 characters required"
// }

// Quick boolean check (also throws error for short text)
try {
  const isAI = isAIGenerated(longText);
  console.log(isAI); // true
} catch (error) {
  console.log("Error:", error.message);
}

// Get confidence score with error handling
try {
  const confidence = getConfidenceScore(longText);
  console.log(confidence); // 0.75
} catch (error) {
  console.log("Error:", error.message);
}

Node.js Usage

const { detectAIText } = require("ai-text-detector");

const text = "Your text here...";
const result = detectAIText(text);
console.log(result);

React Usage

import React, { useState } from "react";
import { detectAIText } from "ai-text-detector";

function AIDetector() {
  const [text, setText] = useState("");
  const [result, setResult] = useState(null);

  const analyzeText = () => {
    if (text.trim()) {
      const detection = detectAIText(text);
      setResult(detection);
    }
  };

  return (
    <div>
      <textarea
        value={text}
        onChange={(e) => setText(e.target.value)}
        placeholder="Enter text to analyze..."
      />
      <button onClick={analyzeText}>Analyze Text</button>

      {result && (
        <div>
          <p>AI Generated: {result.isAIGenerated ? "Yes" : "No"}</p>
          <p>Confidence: {(result.confidence * 100).toFixed(1)}%</p>
          <ul>
            {result.reasons.map((reason, index) => (
              <li key={index}>{reason}</li>
            ))}
          </ul>
        </div>
      )}
    </div>
  );
}

API Reference

`detectAIText(text: string): DetectionResult`

Analyzes the provided text and returns a detailed detection result.

Parameters:

text (string): The text to analyze (minimum 50 characters required)

Returns:

DetectionResult object with the following properties:
- isAIGenerated (boolean): Whether the text is likely AI-generated
- confidence (number): Confidence score between 0 and 1
- reasons (string[]): Array of reasons explaining the detection
- score (number): Raw detection score

Throws:

Error: When text is empty or less than 50 characters

`isAIGenerated(text: string): boolean`

Quick check to determine if text is likely AI-generated.

Parameters:

text (string): The text to analyze (minimum 50 characters required)

Returns:

boolean: True if likely AI-generated, false otherwise

Throws:

Error: When text is empty or less than 50 characters

`getConfidenceScore(text: string): number`

Returns just the confidence score for the detection.

Parameters:

text (string): The text to analyze (minimum 50 characters required)

Returns:

number: Confidence score between 0 and 1

Throws:

Error: When text is empty or less than 50 characters

How It Works

This library uses multiple advanced linguistic analysis techniques to detect AI-generated text:

Core Analysis Methods

Advanced Perplexity Analysis: Enhanced trigram-based model with interpolation to measure text predictability
Burstiness Analysis: Analyzes sentence-to-sentence variation and consistency patterns
Entropy Scoring: Measures word choice predictability (AI tends to be more predictable)
Human-likeness Indicators: Detects informal language, typos, contractions, and emotional expressions
Stylometric Analysis: Examines writing style consistency and variation patterns

Enhanced Pattern Recognition

Modern AI Pattern Detection: Recognizes phrases like "it's worth noting", "as we delve into", "in today's digital age"
Informal Language Recognition: Detects slang, internet abbreviations, contractions, and casual expressions
Emotional Tone Analysis: Measures emotional expression variability and personal narrative styles
Discourse Marker Analysis: Identifies overuse of transition words typical in AI-generated text
Function Word Distribution: Analyzes patterns in common word usage that differ between AI and human writing

Traditional Linguistic Analysis

Vocabulary Richness: Examines word diversity and complexity patterns
Syntactic Complexity: Analyzes sentence structure and grammatical patterns
Semantic Coherence: Measures logical flow and contextual consistency
N-gram Repetition: Detects repetitive patterns common in AI text
Contextual Consistency: Advanced checking for semantic and thematic coherence
Sentence Structure Entropy: Evaluates variety in sentence construction
Topic Coherence Scoring: Measures semantic consistency across text segments

Adaptive Intelligence

Dynamic Thresholding: Adjusts detection sensitivity based on text characteristics
Multi-dimensional Scoring: Combines multiple indicators with optimized weights
Compound Effect Analysis: Multiple human indicators work together for better accuracy
Contextual Awareness: Understands different writing contexts and styles

Performance

Bundle Size: ~15KB minified
Zero Dependencies: No external libraries required
Fast Processing: Analyzes typical documents in <10ms
Memory Efficient: Minimal memory footprint

Browser Support

Chrome 60+
Firefox 55+
Safari 12+
Edge 79+
Node.js 14+

The library analyzes various linguistic patterns commonly found in AI-generated text:

Sentence Structure: AI text often has consistent sentence lengths and patterns
Transition Words: Heavy use of formal transition words (furthermore, moreover, etc.)
Formality Level: AI tends to use more formal vocabulary
Repetitive Patterns: Common phrases and structures used by AI models
Passive Voice: Balanced usage patterns typical of AI optimization
Complexity Analysis: Word length and complexity patterns

Accuracy Notes

Enhanced Accuracy: Version 1.0.3+ includes significant improvements in detecting both AI and human text
Improved Informal Text Detection: Better recognition of casual, emotional, and conversational human writing
Reduced False Positives: Significantly fewer false positives on informal human content
Modern AI Recognition: Enhanced detection of contemporary AI writing patterns and phrases
Adaptive Analysis: Dynamic thresholding adjusts based on text characteristics for better accuracy
Contextual Awareness: Better understanding of different writing contexts and styles
This library uses advanced heuristic analysis and pattern matching techniques
Results should be used as a guide rather than definitive proof
Accuracy continues to improve with each version as new AI patterns are identified
Human-written formal text may occasionally trigger detection, but this has been significantly reduced

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

License

MIT License - see LICENSE file for details.

Changelog

1.0.3 (2025-06-18)

Enhanced Detection: Significantly improved accuracy for both AI and human text
Better Human Recognition: Advanced detection of informal, casual, and emotional writing
Modern AI Patterns: Enhanced recognition of contemporary AI writing styles
Advanced Metrics: Added entropy analysis, human-likeness indicators, and stylometric analysis
Adaptive Thresholding: Dynamic detection sensitivity based on text characteristics
Improved Algorithms: Enhanced perplexity calculation with trigram models
Reduced False Positives: Better handling of informal human content
Backward Compatible: All existing APIs unchanged

1.0.0

Initial release
Basic AI text detection functionality
Support for Node.js and browser environments
TypeScript support