API Documentation

import requests
import time

API_KEY = "your_api_key_here"
BASE_URL = "https://rapi.deceptioner.site"

headers = {
    "Content-Type": "application/json",
    "X-Deceptioner-API-V2": API_KEY
}

def create_task(text, stealth=0.5, ai_detector="GPTZero.me"):
    payload = {
        "text": text,
        "stealth": stealth,
        "ai_detector": ai_detector
    }
    response = requests.post(f"{BASE_URL}/create-task", json=payload, headers=headers)
    return response.json()

def query_task(task_id):
    response = requests.get(f"{BASE_URL}/query-task", params={"task_id": task_id}, headers=headers)
    return response.json(), response.headers.get("Retry-After")

def rewrite_text(text, stealth=0.5, ai_detector="GPTZero.me"):
    # Create the task
    result = create_task(text, stealth, ai_detector)

    if result["status"] == "failed":
        raise Exception(result["message"])

    task_id = result["taskID"]
    print(f"Task created: {task_id}")

    # Poll for results
    while True:
        result, retry_after = query_task(task_id)

        if result["status"] == "completed":
            return result["paraphrased_text"]
        elif result["status"] == "failed":
            raise Exception(result["message"])

        wait_time = int(retry_after) if retry_after else 30
        print(f"Task {result['status']}. Waiting {wait_time} seconds...")
        time.sleep(wait_time)

# Usage
if __name__ == "__main__":
    original_text = "Artificial intelligence has revolutionized the way we interact with technology."
    rewritten = rewrite_text(original_text, stealth=0.7, ai_detector="Originality.ai")
    print(f"Rewritten: {rewritten}")

const axios = require('axios');

const API_KEY = 'your_api_key_here';
const BASE_URL = 'https://rapi.deceptioner.site';

const headers = {
  'Content-Type': 'application/json',
  'X-Deceptioner-API-V2': API_KEY
};

async function createTask(text, stealth = 0.5, aiDetector = 'GPTZero.me') {
  const response = await axios.post(`${BASE_URL}/create-task`, {
    text,
    stealth,
    ai_detector: aiDetector
  }, { headers });

  return response.data;
}

async function queryTask(taskId) {
  const response = await axios.get(`${BASE_URL}/query-task`, {
    params: { task_id: taskId },
    headers
  });

  return {
    data: response.data,
    retryAfter: response.headers['retry-after']
  };
}

async function rewriteText(text, stealth = 0.5, aiDetector = 'GPTZero.me') {
  const createResult = await createTask(text, stealth, aiDetector);

  if (createResult.status === 'failed') {
    throw new Error(createResult.message);
  }

  const taskId = createResult.taskID;
  console.log(`Task created: ${taskId}`);

  while (true) {
    const { data, retryAfter } = await queryTask(taskId);

    if (data.status === 'completed') {
      return data.paraphrased_text;
    } else if (data.status === 'failed') {
      throw new Error(data.message);
    }

    const waitTime = (retryAfter ? parseInt(retryAfter) : 30) * 1000;
    console.log(`Task ${data.status}. Waiting ${waitTime / 1000} seconds...`);
    await new Promise(resolve => setTimeout(resolve, waitTime));
  }
}

// Usage
(async () => {
  try {
    const originalText = 'Artificial intelligence has revolutionized the way we interact with technology.';
    const rewritten = await rewriteText(originalText, 0.7, 'Originality.ai');
    console.log(`Rewritten: ${rewritten}`);
  } catch (error) {
    console.error('Error:', error.message);
  }
})();

Create Task:

curl -X POST "https://rapi.deceptioner.site/create-task" \
  -H "Content-Type: application/json" \
  -H "X-Deceptioner-API-V2: your_api_key_here" \
  -d '{
    "text": "Your text to rewrite goes here.",
    "stealth": 0.5,
    "ai_detector": "GPTZero.me"
  }'

Query Task:

curl -X GET "https://rapi.deceptioner.site/query-task?task_id=550e8400-e29b-41d4-a716-446655440000" \
  -H "X-Deceptioner-API-V2: your_api_key_here"

<?php

$apiKey = 'your_api_key_here';
$baseUrl = 'https://rapi.deceptioner.site';

function createTask($text, $stealth = 0.5, $aiDetector = 'GPTZero.me') {
    global $apiKey, $baseUrl;

    $payload = json_encode([
        'text' => $text,
        'stealth' => $stealth,
        'ai_detector' => $aiDetector
    ]);

    $ch = curl_init("$baseUrl/create-task");
    curl_setopt_array($ch, [
        CURLOPT_POST => true,
        CURLOPT_POSTFIELDS => $payload,
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_HTTPHEADER => [
            'Content-Type: application/json',
            "X-Deceptioner-API-V2: $apiKey"
        ]
    ]);

    $response = curl_exec($ch);
    curl_close($ch);

    return json_decode($response, true);
}

function queryTask($taskId) {
    global $apiKey, $baseUrl;

    $ch = curl_init("$baseUrl/query-task?task_id=$taskId");
    curl_setopt_array($ch, [
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_HEADER => true,
        CURLOPT_HTTPHEADER => [
            "X-Deceptioner-API-V2: $apiKey"
        ]
    ]);

    $response = curl_exec($ch);
    $headerSize = curl_getinfo($ch, CURLINFO_HEADER_SIZE);
    $headers = substr($response, 0, $headerSize);
    $body = substr($response, $headerSize);
    curl_close($ch);

    $retryAfter = null;
    if (preg_match('/Retry-After:\s*(\d+)/i', $headers, $matches)) {
        $retryAfter = (int)$matches[1];
    }

    return [
        'data' => json_decode($body, true),
        'retryAfter' => $retryAfter
    ];
}

function rewriteText($text, $stealth = 0.5, $aiDetector = 'GPTZero.me') {
    $result = createTask($text, $stealth, $aiDetector);

    if ($result['status'] === 'failed') {
        throw new Exception($result['message']);
    }

    $taskId = $result['taskID'];
    echo "Task created: $taskId\n";

    while (true) {
        $queryResult = queryTask($taskId);
        $data = $queryResult['data'];

        if ($data['status'] === 'completed') {
            return $data['paraphrased_text'];
        } elseif ($data['status'] === 'failed') {
            throw new Exception($data['message']);
        }

        $waitTime = $queryResult['retryAfter'] ?? 30;
        echo "Task {$data['status']}. Waiting $waitTime seconds...\n";
        sleep($waitTime);
    }
}

// Usage
try {
    $originalText = 'Artificial intelligence has revolutionized the way we interact with technology.';
    $rewritten = rewriteText($originalText, 0.7, 'Originality.ai');
    echo "Rewritten: $rewritten\n";
} catch (Exception $e) {
    echo "Error: " . $e->getMessage() . "\n";
}

const API_KEY = 'your_api_key_here';
const BASE_URL = 'https://rapi.deceptioner.site';

async function createTask(text, stealth = 0.5, aiDetector = 'GPTZero.me') {
  const response = await fetch(`${BASE_URL}/create-task`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'X-Deceptioner-API-V2': API_KEY
    },
    body: JSON.stringify({
      text,
      stealth,
      ai_detector: aiDetector
    })
  });

  return response.json();
}

async function queryTask(taskId) {
  const response = await fetch(`${BASE_URL}/query-task?task_id=${taskId}`, {
    headers: {
      'X-Deceptioner-API-V2': API_KEY
    }
  });

  return {
    data: await response.json(),
    retryAfter: response.headers.get('Retry-After')
  };
}

async function rewriteText(text, stealth = 0.5, aiDetector = 'GPTZero.me') {
  const createResult = await createTask(text, stealth, aiDetector);

  if (createResult.status === 'failed') {
    throw new Error(createResult.message);
  }

  const taskId = createResult.taskID;

  while (true) {
    const { data, retryAfter } = await queryTask(taskId);

    if (data.status === 'completed') {
      return data.paraphrased_text;
    } else if (data.status === 'failed') {
      throw new Error(data.message);
    }

    const waitTime = (retryAfter ? parseInt(retryAfter) : 30) * 1000;
    await new Promise(resolve => setTimeout(resolve, waitTime));
  }
}

// Usage
rewriteText('Your text here', 0.5, 'GPTZero.me')
  .then(result => console.log(result))
  .catch(err => console.error(err));