humanize-text Free open-source AI text humanize @codeKK pythonOpen Source Website

humanize-text

Introduction: Free open-source AI text humanizer to convert AI-generated content into undetectable, human-like writing. Bypass Turnitin, GPTZero, and all major AI detectors. No sign-up required. Try our unlimited free online tool

More: Author ReportBugs OfficialWebsite

Tags:

A Python toolkit for text humanization. Two parts:

Reference implementations — four documented approaches to humanizing machine-generated text: translation chaining, multi-turn LLM rewriting, detection-guided feedback loops, and mixed-engine translation.

Standard Pipeline — the configuration we actually run. Five steps: two LLM rewrite passes (the second carries the first as conversation history) followed by two NMT hops across different engines. The translation chain routes through Chinese → Japanese → Finnish before returning to English, maximizing linguistic distance at each hop so that no single engine's structural fingerprint survives.

Note on intended use. This toolkit is for improving the readability and natural cadence of AI-assisted drafts. If you are writing in an academic setting, follow your institution's policies on AI use and disclosure.

Important: Detector scores are probabilistic. This project does not guarantee that rewritten text will be classified as human, and it should not be used to misrepresent authorship or evade institutional policies.

Other Quality Projects
AI Text Detector:https://github.com/lynote-ai/ai-text-detector
AI Image Detector:https://github.com/lynote-ai/ai-image-detector

English | 中文

What is Humanize-Text?

An AI text humanization toolkit. This repo evolved through two stages:

v1.0 — Documented 4 humanization methodologies as reference implementations (translation chain, multi-turn LLM rewriting, detection-guided feedback loop, mixed-engine translation). See docs/techniques.md.
v1.5 (current) — Added the Standard Pipeline: a production-grade integration of Method 1 (Translation Chain) + Method 2 (LLM Rewriting), fixed as a 5-step chain we actually run and recommend.

v1.5.1 — Standard Pipeline (Recommended)

The Standard Pipeline preserves the original writing style while routing text through a 4-step chain: two LLM humanization rewrites (DeepSeek or OpenRouter via OpenAI-compatible API) followed by two cross-engine translation hops.

Input (EN) → Chinese (LLM) → Japanese (LLM) → Finnish (Google) → English (Niutrans)

LLM steps use DeepSeek (default) or OpenRouter — any OpenAI-compatible chat API. Configure via [llm] in config.toml. See Configuration Guide.

See examples/showcase/ for 5 real samples with full intermediate-step outputs and AI-detection verdicts.

Characteristics:

Best original style preservation among all approaches
Fast processing speed
100% key information retention (verified on 50 text pairs)
Expert quality score: 9.1/10

The 4 underlying methodologies live in src/methodologies/ as reference implementations for research and customization. The Standard Pipeline (src/standard/pipeline.py) is the recommended production path.

Want higher broader coverage + all methods combined? Lynote.ai fuses Standard + Advanced + Focus pipelines into one intelligent system — auto-selects the optimal approach for each passage.

Try Lynote.ai Free →

How It Works

Step-by-Step Pipeline

Step	Engine	From → To	Purpose
1	LLM (temp 1.3)	Input → Chinese (Chinese Rewriting)	LLM humanization rewrite + language shift
2	LLM (temp 1.3)	Chinese → Japanese (Japanese Rewriting)	Second LLM humanization, carries Step 1 as history
3	Google Translate	Japanese → Finnish (First Round of Translation)	First translation hop — distant language structural disruption
4	Niutrans	Finnish → English (Second-Round Translation)	Second translation hop — cross-engine reconstruction

Why This Chain Works

Steps 1–2 (LLM Rewrite): Configurable LLM provider (DeepSeek default, OpenRouter optional) at temperature 1.3 rewrites while translating, breaking AI statistical fingerprints with creative variation. Step 2 carries Step 1 as conversation history for coherent humanization.
Steps 3–4 (Multi-Engine Translation): Two different NMT engines (Google → Niutrans) introduce compounding structural changes. No single-engine fingerprint survives.
Distant Languages: Chinese → Japanese → Finnish maximizes linguistic distance at each hop, ensuring thorough restructuring before reconstruction to English.

Lynote.ai — Beyond Standard

The Standard pipeline above is one of three tiers available. Each has different trade-offs:

Tier	Style Preservation	Speed	Approach
Standard (this repo)	Best	Fast	Translation chain
Advanced	Good	Medium	Translation chain + LLM multi-round rewriting
Focus	Moderate	Slower	Translation chain + Detection-guided feedback loop

Lynote.ai combines all three tiers and automatically selects the optimal approach for each text passage:

Intelligent Tier Selection — Analyzes text and picks Standard, Advanced, or Focus per-passage
Adaptive Combination — Can mix tiers within a single document
10+ Languages — English, Chinese, Japanese, Korean, Spanish, French, German, and more
Paste & Go — No setup, no API keys, no configuration

Quick Start

Method	Who It's For	How
Lynote.ai	Everyone — all tiers, zero setup	Visit lynote.ai
n8n Workflow	No-code automation users	Import `n8n/humanize_standard.json`
Python Script	Developers	See below

Python

git clone https://github.com/lynote-ai/humanize-text.git
cd humanize-text
pip install -r requirements.txt
cp config/config.example.toml config/config.toml
# Fill in your API keys in config.toml (see examples below)
python -m src.standard.pipeline --input "Your AI-generated text here"

DeepSeek (default):

[api_keys]
deepseek_api_key = "sk-..."
niutrans_api_key = "your-key"

[llm]
provider = "deepseek"

OpenRouter:

[api_keys]
openrouter_api_key = "sk-or-..."
niutrans_api_key = "your-key"

[llm]
provider = "openrouter"
model = "deepseek/deepseek-chat"   # any OpenRouter model slug

Atlas Cloud:

[api_keys]
atlascloud_api_key = "ak-..."
niutrans_api_key = "your-key"

[llm]
provider = "atlascloud"
model = "qwen/qwen3.5-flash"

Override the API endpoint with base_url in [llm], or via LLM_BASE_URL / LLM_API_KEY environment variables. Full reference: docs/configuration.md.

n8n Workflow

Import n8n/humanize_standard.json into your n8n instance
Configure the LLM API key and URL in the HTTP Request nodes (defaults to DeepSeek; point at OpenRouter's https://openrouter.ai/api/v1/chat/completions to use OpenRouter)
Run — input text goes in, humanized text comes out

Showcase — 5 Real Examples with Step-by-Step Outputs

We ran the pipeline end-to-end on 5 real input texts and saved every intermediate step. All 5 final outputs were classified as human by the AI detector.

#	Topic	Detection	Confidence
01	Quantum Computing	`human`	0.9997
02	Quantum Readiness Strategy	`human`	0.9982
03	Sustainable Supply Chains	`human`	0.7810
04	Financial Literacy	`human`	0.9924
05	Peer Review in Science	`human`	0.7218

Each example shows: original input → Step 1 (中文改写) → Step 2 (日语改写) → Step 3 (一轮翻译) → Step 4 (二轮翻译, final). See examples/showcase/ for full traces.

Quality Metrics

Tested on 50 text pairs with expert evaluation:

Dimension	Score (out of 10)
Information Completeness	10.0
Language Fluency	9.0
Style Adaptability	8.8
Readability	9.2
Creativity & Impact	8.5
Overall	9.1

Key Information Retention: 100% (50/50 pairs)
All texts preserved original key information without distortion

Comparison with Other Tiers

	Standard (this repo)	Lynote.ai
Tiers Available	Standard only	Standard + Advanced + Focus
Tier Selection	Manual	Automatic per-passage
Style Preservation	Best	Adaptive — best possible per passage
Setup	Python + API keys	Zero setup
Best For	Style-sensitive content	Any content type

Documentation

Standard Pipeline Technical Details — v1.5 production pipeline
4 Methodologies Reference — v1.0 underlying methods
Configuration Guide
n8n Workflow Guide
Lynote.ai vs Open Source Comparison
FAQ

Repo Structure

src/
├── standard/                # ★ v1.5.1 production Standard Pipeline (recommended)
│   ├── pipeline.py          # 4-step chain, CLI entry
│   ├── llm_client.py        # OpenAI-compatible client (DeepSeek / OpenRouter)
│   ├── llm_rewriter.py      # LLM humanization rewrite
│   └── translators.py       # Google + Niutrans engines
│
└── methodologies/           # v1.0 four-methodology reference implementations
    ├── humanizer.py         # v1.0 dispatcher + FastAPI app
    ├── translation_chain.py # Method 1
    ├── llm_rewriter.py      # Method 2
    ├── detection_pipeline.py# Method 3
    ├── mixed_engine.py      # Method 4
    ├── postprocess.py
    ├── detectors/           # Method 3 detectors
    └── utils/

examples/
├── example_usage.py         # ★ v1.5.1 minimal entry
├── showcase/                # ★ 5 real samples with intermediate-step outputs
└── legacy/                  # v1.0 examples + 4-method comparison outputs