Humanizer AI

Humanizer AI CLI. Detect AI-generated text and humanize it to bypass GPTZero, Turnitin, Originality.ai, Copyleaks, ZeroGPT, and Winston AI. Rewrite AI conten...

Security Scan

The skill's code, install steps, requested environment variables, and runtime instructions are coherent with its stated purpose (a CLI that sends text to HumanizerAI's API to detect and rewrite AI-generated content); there are no unexplained credentials, hidden endpoints, or surprising install actions — but the tool will send any submitted text to a third‑party API, so treat sensitive content and ethical/legal use accordingly.

Purpose & Capability

Name/description (detect and humanize AI text) aligns with the files, package.json, and required binaries. The skill requires an API key and an API URL which are exactly what a remote-API-backed CLI would need. The declared binary name ('humanizerai') and npm package match the package.json and bin entry.

Instruction Scope

SKILL.md and the code instruct the agent to read text from flags, files, or stdin and POST it to /detect or /humanize on the configured API — this is consistent with the stated purpose. Note: the runtime behavior necessarily transmits full user text to the third‑party service; that is expected for this functionality but is an important privacy/data-exfiltration consideration.

Install Mechanism

Install is via the npm package 'humanizerai' (package.json present). This is a typical install mechanism for a Node CLI. No obscure download URLs, shorteners, or extract-from-unknown-host steps are present in the spec or files.

Credentials

The skill requires two environment variables: HUMANIZERAI_API_KEY (primary credential) and optional HUMANIZERAI_API_URL. Both are directly relevant and proportionate for a remote API client. No unrelated secrets, system tokens, or config paths are requested.

Persistence & Privilege

The skill does not request 'always: true', does not modify other skills, and does not attempt to write to system-wide config beyond installing its own binary. Default autonomous invocation is allowed (platform default) and is not combined with other privilege escalations.

Assessment

This package appears internally consistent, but review the following before installing: (1) Privacy: any text you pass (including PII, student work, proprietary text, or secrets) will be sent to the external HumanizerAI API — avoid submitting sensitive content. (2) Trust & billing: the API key grants access to your account/credits and the humanize endpoint charges credits (1 credit = 1 word according to docs); keep keys secret and verify billing limits. (3) Ethics & legal: the tool explicitly aims to help bypass AI/plagiarism detectors; consider academic integrity and legal implications before use. (4) Source verification: the repository and npm package look consistent, but if you plan to install system-wide, verify the package on npm and the GitHub repo (signatures, recent activity, open issues) to ensure you’re running the official publisher’s release. (5) Least privilege: store the API key in a dedicated secret with minimal scope and rotate it if you stop using the service.

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:

Level	What it does	Best for
light	Subtle word changes, preserves style	Already-edited text, low AI scores
medium	Balanced rewriting (default)	Most use cases
aggressive	Maximum rewriting for bypass	High AI scores, strict detectors (Turnitin, GPTZero)

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 < "$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

Plan	Price	Words/Month	API Access
Free	$0	0	No
Starter	$9.99/mo	10,000	No
Pro	$19.99/mo	50,000	Yes (CLI + API)
Business	$49.99/mo	200,000	Yes (CLI + API)

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.