### Install and Configure HumanizerAI CLI

Source: https://context7.com/humanizerai/humanizerai-cli/llms.txt

Global installation via npm and environment variable setup for API authentication.

```bash
# Install globally
npm install -g humanizerai

# Set API key (required for all commands)
export HUMANIZERAI_API_KEY=hum_your_api_key

# Optional: Custom API URL
export HUMANIZERAI_API_URL=https://custom.api.endpoint/v1

# Verify installation
humanizerai --help
```

--------------------------------

### Install HumanizerAI CLI

Source: https://github.com/humanizerai/humanizerai-cli/blob/main/README.md

Install the HumanizerAI CLI globally using npm. This command is required before using any other HumanizerAI CLI commands.

```bash
npm install -g humanizerai
```

--------------------------------

### Install Claude Code Skill

Source: https://github.com/humanizerai/humanizerai-cli/blob/main/README.md

Install the Claude Code skill for integrating HumanizerAI with Claude. This command is intended for use by AI agents.

```bash
npx @anthropic-ai/claude-code /learn humanizerai
```

--------------------------------

### Automate Detection and Humanization

Source: https://github.com/humanizerai/humanizerai-cli/blob/main/SKILL.md

Example script to conditionally humanize text based on detection scores.

```bash
#!/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
```

--------------------------------

### Escalating Humanization Intensity

Source: https://github.com/humanizerai/humanizerai-cli/blob/main/SKILL.md

This script starts with 'light' humanization intensity and escalates to 'medium' or 'aggressive' only if the AI detection score remains too high after the previous attempt. It requires 'jq' for JSON parsing.

```bash
#!/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
```

--------------------------------

### Show Help

Source: https://github.com/humanizerai/humanizerai-cli/blob/main/SKILL.md

Displays the main help message for the HumanizerAI CLI.

```bash
# Help
humanizerai --help                    # Show help
```

--------------------------------

### Show Command Help

Source: https://github.com/humanizerai/humanizerai-cli/blob/main/SKILL.md

Displays the help message for a specific command, such as 'detect'.

```bash
humanizerai detect --help             # Command help
```

--------------------------------

### Configure Environment Variables

Source: https://github.com/humanizerai/humanizerai-cli/blob/main/SKILL.md

Set the required API key for authentication.

```bash
# 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
```

--------------------------------

### HumanizerAI CLI Quick Reference

Source: https://github.com/humanizerai/humanizerai-cli/blob/main/README.md

A concise reference for common HumanizerAI CLI commands, including detection, humanization with different intensities, file processing, and credit checking.

```bash
humanizerai detect -t "text"              # Check AI score (free)
```

```bash
humanizerai humanize -t "text"            # Humanize (medium)
```

```bash
humanizerai humanize -t "text" -i light   # Light touch
```

```bash
humanizerai humanize -t "text" -i aggressive  # Max bypass
```

```bash
humanizerai humanize -f file.txt -r       # File in, text out
```

```bash
humanizerai credits                       # Check balance
```

--------------------------------

### Initialize and Use HumanizerAI TypeScript API

Source: https://context7.com/humanizerai/humanizerai-cli/llms.txt

Demonstrates how to instantiate the API client and perform detection, humanization, and credit checks in a Node.js environment.

```typescript
import { HumanizeRaiAPI, DetectResponse, HumanizeResponse, CreditsResponse } from 'humanizerai';

// Initialize API client
const api = new HumanizeRaiAPI({
  apiKey: 'hum_your_api_key',
  apiUrl: 'https://humanizerai.com/api/v1' // optional, this is default
});

// Detect AI patterns
const detectResult: DetectResponse = await api.detect('Your text to analyze');
console.log(`AI Score: ${detectResult.score.overall}`);
console.log(`Verdict: ${detectResult.verdict}`);

// Humanize text
const humanizeResult: HumanizeResponse = await api.humanize(
  'AI-generated text here',
  'medium' // 'light' | 'medium' | 'aggressive'
);
console.log(`Before: ${humanizeResult.score.before}, After: ${humanizeResult.score.after}`);
console.log(`Humanized: ${humanizeResult.humanizedText}`);

// Check credits
const creditsResult: CreditsResponse = await api.credits();
console.log(`Total credits: ${creditsResult.credits.total}`);
console.log(`Plan: ${creditsResult.plan}`);
```

--------------------------------

### Set Up API Key

Source: https://github.com/humanizerai/humanizerai-cli/blob/main/README.md

Set the HUMANIZERAI_API_KEY environment variable to authenticate with the HumanizerAI service. An API key is required for most operations and can be obtained from the HumanizerAI dashboard.

```bash
export HUMANIZERAI_API_KEY=hum_your_api_key
```

--------------------------------

### Check Account Credits

Source: https://context7.com/humanizerai/humanizerai-cli/llms.txt

Retrieve current credit balance and subscription details.

```bash
# Check credit balance
humanizerai credits

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

# Parse credits for scripting
TOTAL_CREDITS=$(humanizerai credits | jq '.credits.total')
echo "Available credits: $TOTAL_CREDITS"
```

--------------------------------

### Execute Core Workflow

Source: https://github.com/humanizerai/humanizerai-cli/blob/main/SKILL.md

Standard sequence for checking credits, detecting AI patterns, humanizing text, and verifying the result.

```bash
# 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"
```

--------------------------------

### Check Credits

Source: https://github.com/humanizerai/humanizerai-cli/blob/main/SKILL.md

Retrieve current credit balance and subscription details.

```bash
humanizerai credits
```

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

--------------------------------

### HumanizerAI TypeScript API Client

Source: https://context7.com/humanizerai/humanizerai-cli/llms.txt

Demonstrates how to initialize and use the HumanizerAI TypeScript client for detecting AI patterns, humanizing text, and checking credits.

```APIDOC
## HumanizerAI TypeScript API Client

### Description
This section shows how to use the HumanizerAI API programmatically within Node.js applications using the provided TypeScript client.

### Initialization
```typescript
import { HumanizeRaiAPI } from 'humanizerai';

const api = new HumanizeRaiAPI({
  apiKey: 'hum_your_api_key',
  apiUrl: 'https://humanizerai.com/api/v1' // optional, this is default
});
```

### Detect AI Patterns
```typescript
// Detect AI patterns
const detectResult = await api.detect('Your text to analyze');
console.log(`AI Score: ${detectResult.score.overall}`);
console.log(`Verdict: ${detectResult.verdict}`);
```

### Humanize Text
```typescript
// Humanize text
const humanizeResult = await api.humanize(
  'AI-generated text here',
  'medium' // 'light' | 'medium' | 'aggressive'
);
console.log(`Before: ${humanizeResult.score.before}, After: ${humanizeResult.score.after}`);
console.log(`Humanized: ${humanizeResult.humanizedText}`);
```

### Check Credits
```typescript
// Check credits
const creditsResult = await api.credits();
console.log(`Total credits: ${creditsResult.credits.total}`);
console.log(`Plan: ${creditsResult.plan}`);
```
```

--------------------------------

### Content Pipeline: Generate, Detect, Humanize, Post

Source: https://github.com/humanizerai/humanizerai-cli/blob/main/SKILL.md

A script demonstrating a full content automation pipeline. It generates content, checks its AI detection score, humanizes it if necessary, and then prepares it for use. Requires 'jq' for JSON parsing.

```bash
#!/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"
```

--------------------------------

### Check Credits

Source: https://github.com/humanizerai/humanizerai-cli/blob/main/README.md

Use the 'credits' command to check your remaining balance of humanization credits.

```bash
humanizerai credits
```

--------------------------------

### Analyze Text with Detect Command

Source: https://context7.com/humanizerai/humanizerai-cli/llms.txt

Perform AI pattern analysis on inline text, files, or piped input. Detection is free and does not consume credits.

```bash
# Detect from inline text
humanizerai detect -t "The emergence of artificial intelligence represents a paradigm shift in how we approach complex problem-solving across various domains."

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

# Detect from file
humanizerai detect -f essay.txt

# Pipe from stdin
cat document.txt | humanizerai detect
echo "Text to analyze" | humanizerai detect

# Parse score with jq for scripting
SCORE=$(humanizerai detect -t "Your text here" | jq '.score')
echo "AI Score: $SCORE"
```

--------------------------------

### Check Account Credits

Source: https://github.com/humanizerai/humanizerai-cli/blob/main/SKILL.md

Displays the current balance of available credits for humanization.

```bash
# Account
humanizerai credits                   # Check balance
```

--------------------------------

### Check Credits Before Large Jobs

Source: https://github.com/humanizerai/humanizerai-cli/blob/main/SKILL.md

Calculates the total word count of files in the 'drafts' directory and compares it against available HumanizerAI credits. Exits with an error if credits are insufficient. Requires 'wc' and 'jq'.

```bash
#!/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
```

--------------------------------

### Detect AI Content - From File

Source: https://github.com/humanizerai/humanizerai-cli/blob/main/SKILL.md

Detects AI-generated content from a specified text file. This operation is free and does not consume credits.

```bash
humanizerai detect -f file.txt        # From file
```

--------------------------------

### Batch Humanize Multiple Files

Source: https://github.com/humanizerai/humanizerai-cli/blob/main/SKILL.md

Iterates through all .txt files in the 'drafts' directory, humanizes each one, and saves the output to the 'humanized' directory. Ensure the 'drafts' and 'humanized' directories exist.

```bash
#!/bin/bash

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

--------------------------------

### Automate Detect-Humanize-Verify Workflow

Source: https://context7.com/humanizerai/humanizerai-cli/llms.txt

A shell script demonstrating a conditional workflow that detects AI content and humanizes it only if the score exceeds a threshold.

```bash
#!/bin/bash
# Complete detect-humanize-verify workflow

TEXT="The implementation of machine learning algorithms has revolutionized data processing capabilities across multiple industry sectors."

# Step 1: Check initial AI score
echo "Analyzing original text..."
INITIAL=$(humanizerai detect -t "$TEXT")
SCORE=$(echo "$INITIAL" | jq '.score')
echo "Initial AI score: $SCORE"

# Step 2: Humanize if score exceeds threshold
if [ "$SCORE" -gt 40 ]; then
  echo "Score too high, humanizing..."
  RESULT=$(humanizerai humanize -t "$TEXT" -i medium)
  HUMANIZED=$(echo "$RESULT" | jq -r '.humanizedText')
  BEFORE=$(echo "$RESULT" | jq '.score.before')
  AFTER=$(echo "$RESULT" | jq '.score.after')
  echo "Humanized. Score: $BEFORE -> $AFTER"

  # Step 3: Verify with fresh detection
  VERIFY_SCORE=$(humanizerai detect -t "$HUMANIZED" | jq '.score')
  echo "Verified score: $VERIFY_SCORE"

  echo ""
  echo "Final text:"
  echo "$HUMANIZED"
else
  echo "Score acceptable, no humanization needed"
fi
```

--------------------------------

### Humanize AI Content

Source: https://github.com/humanizerai/humanizerai-cli/blob/main/SKILL.md

Rewrite text to bypass detectors using different intensity levels.

```bash
# 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
```

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

--------------------------------

### Detect AI Content - From Standard Input

Source: https://github.com/humanizerai/humanizerai-cli/blob/main/SKILL.md

Detects AI-generated content by piping text into the command. This operation is free and does not consume credits.

```bash
cat file.txt | humanizerai detect     # From stdin
```

--------------------------------

### Batch Process Files with Credit Verification

Source: https://context7.com/humanizerai/humanizerai-cli/llms.txt

A shell script to process multiple text files in a directory, ensuring sufficient credits exist before execution.

```bash
#!/bin/bash
# Batch humanize all .txt files in drafts/ directory

INPUT_DIR="drafts"
OUTPUT_DIR="humanized"
mkdir -p "$OUTPUT_DIR"

# Pre-check: Count total words and verify credits
TOTAL_WORDS=0
for file in "$INPUT_DIR"/*.txt; do
  [ -f "$file" ] || continue
  WORDS=$(wc -w < "$file")
  TOTAL_WORDS=$((TOTAL_WORDS + WORDS))
done

CREDITS=$(humanizerai credits | jq '.credits.total')
echo "Total words to process: $TOTAL_WORDS"
echo "Credits available: $CREDITS"

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

# Process each file
for file in "$INPUT_DIR"/*.txt; do
  [ -f "$file" ] || continue
  BASENAME=$(basename "$file")
  echo "Processing: $BASENAME"

  # Detect first to check if humanization needed
  SCORE=$(humanizerai detect -f "$file" | jq '.score')

  if [ "$SCORE" -gt 40 ]; then
    humanizerai humanize -f "$file" -i medium -r > "$OUTPUT_DIR/$BASENAME"
    echo "  Humanized (score was $SCORE)"
  else
    cp "$file" "$OUTPUT_DIR/$BASENAME"
    echo "  Copied (score $SCORE acceptable)"
  fi
done

echo "Done. Output in $OUTPUT_DIR/"
```

--------------------------------

### Humanize Text - Light Intensity

Source: https://github.com/humanizerai/humanizerai-cli/blob/main/SKILL.md

Humanizes provided text with a light touch. This operation consumes credits (1 credit per word).

```bash
humanizerai humanize -t "text" -i light         # Light touch
```

--------------------------------

### Detect AI Text

Source: https://github.com/humanizerai/humanizerai-cli/blob/main/README.md

Use the 'detect' command to check the AI score of a given text. This feature is free and unlimited. You can provide text directly, from a file, or via standard input.

```bash
humanizerai detect -t "Text to check"
```

```bash
humanizerai detect -f essay.txt
```

```bash
cat draft.txt | humanizerai detect
```

--------------------------------

### Interact with HumanizerAI REST API Endpoints

Source: https://context7.com/humanizerai/humanizerai-cli/llms.txt

Provides cURL commands for direct interaction with the detection, humanization, and credit endpoints.

```bash
# Detect endpoint (POST /api/v1/detect)
curl -X POST https://humanizerai.com/api/v1/detect \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer hum_your_api_key" \
  -d '{"text": "Your text to analyze for AI patterns"}'

# Response:
# {
#   "score": {"overall": 82, "perplexity": 96, ...},
#   "wordCount": 8,
#   "sentenceCount": 1,
#   "verdict": "Highly likely AI-generated"
# }

# Humanize endpoint (POST /api/v1/humanize)
curl -X POST https://humanizerai.com/api/v1/humanize \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer hum_your_api_key" \
  -d '{"text": "AI text to rewrite", "intensity": "medium"}'

# Response:
# {
#   "humanizedText": "Rewritten text here",
#   "score": {"before": 85, "after": 22},
#   "wordsProcessed": 5,
#   "credits": {"subscriptionRemaining": 49995, ...}
# }

# Credits endpoint (GET /api/v1/credits)
curl -X GET https://humanizerai.com/api/v1/credits \
  -H "Authorization: Bearer hum_your_api_key"

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

--------------------------------

### Humanize AI Text

Source: https://github.com/humanizerai/humanizerai-cli/blob/main/README.md

Use the 'humanize' command to rewrite AI-generated text. This operation consumes credits (1 credit = 1 word). You can specify the intensity of the humanization.

```bash
humanizerai humanize -t "AI text to rewrite"
```

```bash
humanizerai humanize -t "Text" -i aggressive
```

```bash
humanizerai humanize -f draft.txt -r > final.txt
```

--------------------------------

### Rewrite Text with Humanize Command

Source: https://context7.com/humanizerai/humanizerai-cli/llms.txt

Rewrite text at different intensity levels to bypass detectors. Consumes 1 credit per word processed.

```bash
# Humanize with default medium intensity
humanizerai humanize -t "Artificial intelligence has fundamentally transformed the landscape of modern computing."

# Output:
# {
#   "humanizedText": "AI has really changed how modern computing works in some big ways.",
#   "score": {
#     "before": 85,
#     "after": 22
#   },
#   "wordsProcessed": 10,
#   "credits": {
#     "subscriptionRemaining": 49990,
#     "topUpRemaining": 0,
#     "totalRemaining": 49990
#   }
# }

# Light intensity - subtle changes, preserves style
humanizerai humanize -t "Your AI text" -i light

# Medium intensity - balanced rewriting (default)
humanizerai humanize -t "Your AI text" -i medium

# Aggressive intensity - maximum rewriting for strict detectors
humanizerai humanize -t "Your AI text" -i aggressive

# Humanize from file
humanizerai humanize -f draft.txt

# Raw output mode - returns only humanized text (no JSON)
humanizerai humanize -t "AI generated content" -r
# Output: AI generated content rewritten naturally

# Save humanized output to file
humanizerai humanize -f input.txt -r > output.txt

# Pipe from stdin with raw output
cat essay.txt | humanizerai humanize -i aggressive -r > humanized-essay.txt
```

--------------------------------

### Detect AI Content - Inline Text

Source: https://github.com/humanizerai/humanizerai-cli/blob/main/SKILL.md

Detects AI-generated content from a provided string. This operation is free and does not consume credits.

```bash
# Detection (free)
humanizerai detect -t "text"          # Inline text
```

--------------------------------

### Humanize via Standard Input - Raw Output

Source: https://github.com/humanizerai/humanizerai-cli/blob/main/SKILL.md

Pipes text into the humanize command and outputs only the humanized text, without JSON formatting. This operation consumes credits (1 credit per word).

```bash
cat file.txt | humanizerai humanize -r          # Pipe in, text out
```

--------------------------------

### Set API Key Environment Variable

Source: https://github.com/humanizerai/humanizerai-cli/blob/main/SKILL.md

Sets the HumanizerAI API key as an environment variable. This is required before using the CLI for any authenticated operations.

```bash
# Environment
export HUMANIZERAI_API_KEY=hum_your_key
```

--------------------------------

### Humanize Text - Medium Intensity

Source: https://github.com/humanizerai/humanizerai-cli/blob/main/SKILL.md

Humanizes provided text with medium intensity. This operation consumes credits (1 credit per word).

```bash
# Humanization (1 credit = 1 word)
humanizerai humanize -t "text"                  # Medium intensity
```

--------------------------------

### Detect AI Patterns

Source: https://github.com/humanizerai/humanizerai-cli/blob/main/SKILL.md

Analyze text from various sources to determine the likelihood of AI generation.

```bash
# 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
```

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

--------------------------------

### Humanize File

Source: https://github.com/humanizerai/humanizerai-cli/blob/main/SKILL.md

Humanizes the content of a specified text file. This operation consumes credits (1 credit per word).

```bash
humanizerai humanize -f file.txt                # From file
```

--------------------------------

### Escalate intensity until score drops below threshold

Source: https://context7.com/humanizerai/humanizerai-cli/llms.txt

Iteratively applies humanization with increasing intensity levels until the detection score falls below the specified target.

```bash
TEXT="Your AI-generated content that needs to pass strict detection"
TARGET_SCORE=30

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

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

  echo "  Score $AFTER still above target $TARGET_SCORE, escalating..."
  TEXT=$(echo "$RESULT" | jq -r '.humanizedText')
done

echo "Warning: Could not achieve target score even with aggressive intensity"
```

--------------------------------

### HumanizerAI REST API Endpoints

Source: https://context7.com/humanizerai/humanizerai-cli/llms.txt

Directly interact with the HumanizerAI REST API for custom integrations. Includes endpoints for detection, humanization, and credit checks.

```APIDOC
## REST API Endpoints

### Detect Endpoint

#### Description
Detects AI patterns in the provided text.

#### Method
POST

#### Endpoint
`/api/v1/detect`

#### Request Body
- **text** (string) - Required - The text to analyze for AI patterns.

#### Request Example
```json
{
  "text": "Your text to analyze for AI patterns"
}
```

#### Success Response (200)
- **score** (object) - Object containing AI detection scores (e.g., `overall`, `perplexity`).
- **wordCount** (integer) - The number of words in the analyzed text.
- **sentenceCount** (integer) - The number of sentences in the analyzed text.
- **verdict** (string) - A verdict on the likelihood of the text being AI-generated.

#### Response Example
```json
{
  "score": {"overall": 82, "perplexity": 96},
  "wordCount": 8,
  "sentenceCount": 1,
  "verdict": "Highly likely AI-generated"
}
```

### Humanize Endpoint

#### Description
Rewrites the provided text to sound more human-like.

#### Method
POST

#### Endpoint
`/api/v1/humanize`

#### Request Body
- **text** (string) - Required - The AI-generated text to rewrite.
- **intensity** (string) - Optional - The level of humanization to apply. Options: `light`, `medium`, `aggressive`. Defaults to `medium`.

#### Request Example
```json
{
  "text": "AI text to rewrite",
  "intensity": "medium"
}
```

#### Success Response (200)
- **humanizedText** (string) - The rewritten, more human-like text.
- **score** (object) - Object containing AI scores before and after humanization (e.g., `before`, `after`).
- **wordsProcessed** (integer) - The number of words processed during humanization.
- **credits** (object) - Information about credit usage.

#### Response Example
```json
{
  "humanizedText": "Rewritten text here",
  "score": {"before": 85, "after": 22},
  "wordsProcessed": 5,
  "credits": {"subscriptionRemaining": 49995}
}
```

### Credits Endpoint

#### Description
Retrieves information about the user's current credit balance and plan.

#### Method
GET

#### Endpoint
`/api/v1/credits`

#### Success Response (200)
- **credits** (object) - Object containing credit details (e.g., `subscription`, `topUp`, `total`).
- **plan** (string) - The current subscription plan (e.g., `pro`).
- **billingCycleEnd** (string) - The end date of the current billing cycle.

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

--------------------------------

### Humanize Text - Aggressive Intensity

Source: https://github.com/humanizerai/humanizerai-cli/blob/main/SKILL.md

Humanizes provided text with maximum intensity to bypass strict detectors. This operation consumes credits (1 credit per word).

```bash
humanizerai humanize -t "text" -i aggressive    # Max bypass
```

--------------------------------

### Humanize File - Raw Output

Source: https://github.com/humanizerai/humanizerai-cli/blob/main/SKILL.md

Humanizes the content of a specified text file and outputs only the humanized text, without JSON formatting. Useful for saving directly to another file. This operation consumes credits (1 credit per word).

```bash
humanizerai humanize -f file.txt -r > out.txt   # Raw output to file
```

--------------------------------

### Escalating Intensity Pattern

Source: https://context7.com/humanizerai/humanizerai-cli/llms.txt

A shell script template for automatically increasing humanization intensity until a target score is met.

```bash
#!/bin/bash
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.