3. StealthWriter API

Integration Patterns and Examples

1. Node.js Integration

`bash
npm install axios dotenv
`

`javascript
const axios = require("axios");
require("dotenv").config();
class ChatGPTHumanizer {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseURL = "https://api.text-polish.com";
  }
async humanize(text, options = {}) {
    try {
      const response = await axios.post(
        ${this.baseURL}/humanize,
        {
          text,
          mode: options.mode || "academic",
          strength: options.strength || "medium",
          preserveCitations: options.preserveCitations || true,
        },
        {
          headers: {
            Authorization: Bearer ${this.apiKey},
            "Content-Type": "application/json",
          },
        }
      );

return response.data;
    } catch (error) {
      console.error("Humanization failed:", error.response?.data);
      throw error;
    }
  }
async batchHumanize(texts, options = {}) {
    const promises = texts.map((text) => this.humanize(text, options));
    return Promise.all(promises);
  }
}
// Usage
const humanizer = new ChatGPTHumanizer(process.env.TEXT_POLISH_API_KEY);
async function processContent() {
  const content = "Your AI-generated content here...";
  const result = await humanizer.humanize(content, {
    mode: "academic",
    strength: "medium",
  });
console.log("Original:", content);
  console.log("Humanized:", result.humanizedText);
  console.log("Quality Score:", result.qualityScore);
}
`

2. Python Integration

`bash
pip install requests python-dotenv
`

`python
import requests
import os
from dotenv import load_dotenv
load_dotenv()
class ChatGPTHumanizer:
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = "https://api.text-polish.com"
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }
def humanize(self, text, mode="academic", strength="medium"):
        payload = {
            "text": text,
            "mode": mode,
            "strength": strength,
            "preserveCitations": True
        }
response = requests.post(
            f"{self.base_url}/humanize",
            json=payload,
            headers=self.headers
        )
if response.status_code == 200:
            return response.json()
        else:
            raise Exception(f"API Error: {response.status_code} - {response.text}")
def batch_humanize(self, texts, options):
        results = []
        for text in texts:
            result = self.humanize(text, options)
            results.append(result)
        return results
Usage
humanizer = ChatGPTHumanizer(os.getenv("TEXT_POLISH_API_KEY"))
content = "Your AI-generated content here..."
result = humanizer.humanize(
    content,
    mode="academic",
    strength="medium"
)
print(f"Original: {content}")
print(f"Humanized: {result['humanizedText']}")
print(f"Quality Score: {result['qualityScore']}")
`

3. PHP Integration

`php
class ChatGPTHumanizer {
    private $apiKey;
    private $baseURL;

public function __construct($apiKey) {
        $this->apiKey = $apiKey;
        $this->baseURL = 'https://api.text-polish.com';
    }
public function humanize($text, $options = []) {
        $data = [
            'text' => $text,
            'mode' => $options['mode'] ?? 'academic',
            'strength' => $options['strength'] ?? 'medium',
            'preserveCitations' => $options['preserveCitations'] ?? true
        ];
$ch = curl_init();
        curl_setopt($ch, CURLOPT_URL, $this->baseURL . '/humanize');
        curl_setopt($ch, CURLOPT_POST, true);
        curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_HTTPHEADER, [
            'Authorization: Bearer ' . $this->apiKey,
            'Content-Type: application/json'
        ]);
$response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);
if ($httpCode === 200) {
            return json_decode($response, true);
        } else {
            throw new Exception("API Error: $httpCode - $response");
        }
    }
}
// Usage
$humanizer = new ChatGPTHumanizer(getenv('TEXT_POLISH_API_KEY'));
$result = $humanizer->humanize("Your content here", [
    'mode' => 'academic',
    'strength' => 'medium'
]);
echo "Humanized: " . $result['humanizedText'];
?>
`

Advanced Implementation Strategies

1. Async Processing for Large Documents

`javascript
class AsyncHumanizer {
  async processLargeDocument(document, chunkSize = 1000) {
    const chunks = this.splitIntoChunks(document, chunkSize);
    const processedChunks = [];
for (const chunk of chunks) {
      const result = await this.humanize(chunk.text);
      processedChunks.push({
        ...chunk,
        humanizedText: result.humanizedText,
      });
// Rate limiting
      await this.delay(100);
    }
return this.reassembleDocument(processedChunks);
  }
splitIntoChunks(text, maxWords) {
    // Implementation for splitting text while preserving context
    const sentences = text.split(". ");
    const chunks = [];
    let currentChunk = "";
for (const sentence of sentences) {
      if ((currentChunk + sentence).split(" ").length <= maxWords) {
        currentChunk += sentence + ". ";
      } else {
        if (currentChunk) {
          chunks.push({ text: currentChunk.trim() });
          currentChunk = sentence + ". ";
        }
      }
    }
if (currentChunk) {
      chunks.push({ text: currentChunk.trim() });
    }
return chunks;
  }
delay(ms) {
    return new Promise((resolve) => setTimeout(resolve, ms));
  }
}
`

2. Quality Monitoring and Fallback

`javascript
class RobustHumanizer {
  constructor() {
    this.apis = [
      new TextPolishAPI(process.env.TEXT_POLISH_KEY),
      new UndetectableAPI(process.env.UNDETECTABLE_KEY),
      new StealthWriterAPI(process.env.STEALTH_KEY),
    ];
  }
async humanizeWithFallback(text, qualityThreshold = 0.8) {
    for (const api of this.apis) {
      try {
        const result = await api.humanize(text);
if (result.qualityScore >= qualityThreshold) {
          return result;
        }
      } catch (error) {
        console.warn(API ${api.constructor.name} failed:, error.message);
        continue;
      }
    }

throw new Error(
      "All humanization APIs failed or quality threshold not met"
    );
  }
}
`

3. Caching and Performance Optimization

`javascript
const Redis = require("redis");
const crypto = require("crypto");
class CachedHumanizer {
  constructor(apiKey, redisConfig) {
    this.humanizer = new ChatGPTHumanizer(apiKey);
    this.redis = Redis.createClient(redisConfig);
  }
generateCacheKey(text, options) {
    const content = text + JSON.stringify(options);
    return crypto.createHash("md5").update(content).digest("hex");
  }
async humanize(text, options = {}, cacheTTL = 3600) {
    const cacheKey = this.generateCacheKey(text, options);
// Check cache first
    const cached = await this.redis.get(cacheKey);
    if (cached) {
      return JSON.parse(cached);
    }
// Process and cache result
    const result = await this.humanizer.humanize(text, options);
    await this.redis.setex(cacheKey, cacheTTL, JSON.stringify(result));
return result;
  }
}
`

Webhook Integration for Async Processing

Setting Up Webhooks

`javascript
const express = require("express");
const app = express();
// Webhook endpoint for processing completion
app.post("/webhook/humanization-complete", (req, res) => {
  const { jobId, status, result, error } = req.body;
if (status === "completed") {
    console.log(Job ${jobId} completed successfully);
    // Process the humanized result
    handleCompletedHumanization(jobId, result);
  } else if (status === "failed") {
    console.error(Job ${jobId} failed:, error);
    // Handle error case
    handleFailedHumanization(jobId, error);
  }

res.status(200).json({ received: true });
});
// Submit async job
async function submitAsyncJob(text, webhookURL) {
  const response = await fetch("https://api.text-polish.com/humanize/async", {
    method: "POST",
    headers: {
      Authorization: "Bearer " + apiKey,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      text,
      webhookURL,
      mode: "academic",
    }),
  });
const { jobId } = await response.json();
  return jobId;
}
`

Error Handling and Rate Limiting

Comprehensive Error Handling