Humanizer AI CLI

AI text detection and humanization from the command line. Detect AI patterns and rewrite text to bypass GPTZero, Turnitin, Originality.ai, and other detectors.

Install

npm install -g humanizerai

npm release: https://www.npmjs.com/package/humanizerai official website: https://humanizerai.com API docs: https://humanizerai.com/docs/api

Core Workflow

The fundamental pattern for using HumanizerAI CLI:

1. Check - Verify credits and API key
2. Detect - Analyze text for AI patterns (free)
3. Humanize - Rewrite to bypass detectors (uses credits)
4. Verify - Re-detect to confirm improvement

# 1. Check credits
humanizerai credits

# 2. Detect AI patterns (free, unlimited)
humanizerai detect -t "Your text here"

# 3. Humanize if score is high
humanizerai humanize -t "Your text here" -i medium

# 4. Verify improvement
humanizerai detect -t "The humanized text"

Essential Commands

Setup

# Required environment variable
export HUMANIZERAI_API_KEY=hum_your_api_key

# Get your API key at https://humanizerai.com/dashboard
# Requires Pro or Business plan for API access

AI Detection (free, no credits)

# Detect from inline text
humanizerai detect -t "Text to analyze"

# Detect from file
humanizerai detect -f essay.txt

# Pipe from stdin
echo "Text to check" | humanizerai detect
cat draft.txt | humanizerai detect

Response:

{
  "score": 82,
  "metrics": {
    "perplexity": 96,
    "burstiness": 15,
    "readability": 23,
    "satPercent": 3,
    "simplicity": 35,
    "ngramScore": 8,
    "averageSentenceLength": 21
  },
  "verdict": "Highly likely AI-generated",
  "wordsProcessed": 82
}

Score interpretation:

• 0-20: Human-written
• 21-40: Likely human, minor AI patterns
• 41-60: Mixed signals
• 61-80: Likely AI-generated
• 81-100: Highly likely AI-generated

Humanization (1 credit = 1 word)

# Humanize with default intensity (medium)
humanizerai humanize -t "Your AI-generated text"

# Choose intensity level
humanizerai humanize -t "Text" -i light
humanizerai humanize -t "Text" -i medium
humanizerai humanize -t "Text" -i aggressive

# Humanize from file
humanizerai humanize -f draft.txt

# Raw output (just the humanized text, for piping)
humanizerai humanize -t "Text" -r
humanizerai humanize -f draft.txt -r > final.txt

# Pipe from stdin
cat essay.txt | humanizerai humanize -r > humanized-essay.txt

Response:

{
  "humanizedText": "The rewritten text appears here...",
  "score": {
    "before": 85,
    "after": 22
  },
  "wordsProcessed": 150,
  "credits": {
    "subscriptionRemaining": 49850,
    "topUpRemaining": 0,
    "totalRemaining": 49850
  }
}

Intensity levels:

Credit Check

humanizerai credits

Response:

{
  "credits": {
    "subscription": 50000,
    "topUp": 0,
    "total": 50000
  },
  "plan": "pro",
  "billingCycleEnd": "2026-04-01T00:00:00.000Z"
}

Common Patterns

Pattern 1: Detect, Humanize, Verify

The standard workflow for ensuring text passes AI detectors:

#!/bin/bash

# Step 1: Check current AI score
SCORE=$(humanizerai detect -t "Your text" | jq '.score')
echo "Current AI score: $SCORE"

# Step 2: If score > 40, humanize it
if [ "$SCORE" -gt 40 ]; then
  RESULT=$(humanizerai humanize -t "Your text" -i medium)
  HUMANIZED=$(echo "$RESULT" | jq -r '.humanizedText')
  echo "Humanized. Score: $(echo "$RESULT" | jq '.score.before') -> $(echo "$RESULT" | jq '.score.after')"

  # Step 3: Verify the result
  NEW_SCORE=$(humanizerai detect -t "$HUMANIZED" | jq '.score')
  echo "Verified score: $NEW_SCORE"
fi

Pattern 2: Batch Humanize Multiple Files

#!/bin/bash

for file in drafts/*.txt; do
  echo "Processing: $file"
  humanizerai humanize -f "$file" -r > "humanized/$(basename "$file")"
  echo "Done: $file"
done

Pattern 3: Content Pipeline (Generate, Humanize, Post)

Use with other agent tools for a full content automation pipeline:

#!/bin/bash

# 1. Generate content (from any AI)
DRAFT="Your AI-generated content here..."

# 2. Check if it needs humanizing
SCORE=$(echo "$DRAFT" | humanizerai detect | jq '.score')

if [ "$SCORE" -gt 40 ]; then
  # 3. Humanize it
  FINAL=$(echo "$DRAFT" | humanizerai humanize -i medium -r)
else
  FINAL="$DRAFT"
fi

# 4. Use the content (post to social media, save to file, etc.)
echo "$FINAL"

Pattern 4: Escalating Intensity

Start with light touch, escalate only if needed:

#!/bin/bash

TEXT="Your AI text here"

for INTENSITY in light medium aggressive; do
  RESULT=$(humanizerai humanize -t "$TEXT" -i "$INTENSITY")
  AFTER=$(echo "$RESULT" | jq '.score.after')

  if [ "$AFTER" -lt 30 ]; then
    echo "Success with $INTENSITY intensity (score: $AFTER)"
    echo "$RESULT" | jq -r '.humanizedText'
    break
  fi

  echo "$INTENSITY: score $AFTER (too high, escalating...)"
  TEXT=$(echo "$RESULT" | jq -r '.humanizedText')
done

Pattern 5: Check Credits Before Large Jobs

#!/bin/bash

# Count words in all files
TOTAL_WORDS=0
for file in drafts/*.txt; do
  WORDS=$(wc -w \x3C "$file")
  TOTAL_WORDS=$((TOTAL_WORDS + WORDS))
done

# Check available credits
CREDITS=$(humanizerai credits | jq '.credits.total')

echo "Words to process: $TOTAL_WORDS"
echo "Credits available: $CREDITS"

if [ "$TOTAL_WORDS" -gt "$CREDITS" ]; then
  echo "Not enough credits. Top up at https://humanizerai.com/dashboard"
  exit 1
fi

Supported AI Detectors

HumanizerAI is tested against and optimized to bypass:

• GPTZero (most common academic detector)
• Turnitin (university standard)
• Originality.ai (content marketing standard)
• Copyleaks (enterprise)
• ZeroGPT (free detector)
• Winston AI (publishing)

Pricing & Plans

Detection is always free and unlimited. Only humanization uses credits.

Top up at: https://humanizerai.com/dashboard

Common Gotchas

1. API key not set - Always export HUMANIZERAI_API_KEY=hum_your_key before using CLI
2. No API access on free/starter - CLI requires Pro or Business plan
3. Detection score format - The main score is the top-level score field (0-100), not nested
4. Credits are per-word - A 500-word essay uses 500 credits to humanize
5. Detection is free - Never costs credits, run it as many times as needed
6. Intensity matters - Start with medium. Only use aggressive for high scores (70+) or strict detectors
7. Raw mode for piping - Use -r flag to get just the text output without JSON wrapper
8. File encoding - Input files must be UTF-8 encoded text
9. Max text length - 10,000 words per request. Split longer documents.
10. Re-detect after humanizing - Always verify the score improved. Occasionally a second pass is needed.

Quick Reference

# Environment
export HUMANIZERAI_API_KEY=hum_your_key

# Detection (free)
humanizerai detect -t "text"          # Inline text
humanizerai detect -f file.txt        # From file
cat file.txt | humanizerai detect     # From stdin

# Humanization (1 credit = 1 word)
humanizerai humanize -t "text"                  # Medium intensity
humanizerai humanize -t "text" -i light         # Light touch
humanizerai humanize -t "text" -i aggressive    # Max bypass
humanizerai humanize -f file.txt                # From file
humanizerai humanize -f file.txt -r > out.txt   # Raw output to file
cat file.txt | humanizerai humanize -r          # Pipe in, text out

# Account
humanizerai credits                   # Check balance

# Help
humanizerai --help                    # Show help
humanizerai detect --help             # Command help

Discover More Skills

Find more AI agent skills at https://agentskill.sh including tools for content generation, social media posting, SEO optimization, and more.