Ryne Logo
REST API
v1 Stable

Ryne API Reference

AI Humanizer API

Ryne's AI humanizer API runs the same Supernova engine as the app. POST a draft with your ryne_sk_ key and get the rewrite back as JSON or a stream. $0.08 per 1,000 words, prepaid.

Humanize AI-generated text and detect AI content with simple, powerful APIs.

Get started

Pricing and API credits

$0.08/ 1K words

Both APIs. No hidden fees.

99.99%
Uptime
~100ms
Latency
No rate limitsNo minimumsPrepaid creditsTop up anytime
10K words$0.80
100K words$8.00
1M words$80.00
Volume discounts available
Your balance

Sign in to view balance.

Sign in

API credits are separate from the coins in Ryne's subscription plans.

Quick Start

Get up and running in under a minute. One endpoint, one API key, one request.

const response = await fetch("https://ryne.ai/api/humanizer/models/supernova", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    text: "Your AI-generated content goes here...",
    tone: "professional",
    purpose: "blog post",
    language: "english",
    user_id: "your_api_key",
    shouldStream: false,
    beast_mode: true,
    // Optional: pass a Writing DNA string to match a personal voice
    // writingDna: "Write in a style that uses short sentences, favors ...",
  }),
});

const data = await response.json();
console.log(data.content);
console.log(data.aiScore); // Final Beast Mode detector score, when available
That's it. The response contains your humanized text in data.content.

Authentication

Generate a key with the Manage API key button above and send it as user_id in the JSON request body. Keys start with ryne_sk_ and are shown once.

Request body
{
  "text": "Content to process",
  "user_id": "ryne_sk_your_api_key_here"
}

Security best practices

  • Never expose your key in client-side code
  • Make API calls from your backend server
  • Use environment variables to store your key
  • If a key leaks, regenerate it immediately; the old key stops working at once

Humanizer API

Transform AI-generated text into natural, human-like content. Supports real-time streaming, multiple processing modes, and fine-grained control over output style.

AI-Adaptive Parameters

Unlike traditional APIs with fixed dropdown options, the tone, purpose, and language parameters accept any string value. Our AI dynamically understands your intent and adapts the output accordingly.

tone
"professional""casual""witty""academic""gen-z""poetic""sarcastic"...anything
purpose
"blog post""email""essay""research paper""social media""ad copy""documentation"...anything
language
"english""spanish""french""japanese""arabic""hindi""german"...anything

Request Parameters

All parameters are sent in the JSON request body.

textstringREQUIRED

The AI-generated text to humanize.

tonestringREQUIRED ADAPTIVE

The desired tone of the output. Accepts any descriptive string — the AI interprets and adapts.

purposestringREQUIRED ADAPTIVE

The intended purpose or context. Accepts any descriptive string — the AI tailors its rewriting style.

languagestring ADAPTIVE= "english"

Output language. Balanced accepts any supported language. Aggressive currently accepts English only.

user_idstringREQUIRED

Your API key for authentication and billing.

shouldStreamboolean= true

Enable NDJSON streaming. Aggressive emits each completed chunk in document order instead of waiting for the full document.

beast_modeboolean= true

When enabled, the API performs multiple passes with AI-detection checks to maximize undetectability. Aggressive mode runs at most three total attempts.

modestring= "normal"

Processing intensity. "lite" disables beast mode for faster results. "normal" enables beast mode.

humanizerModestring= "balanced"

Which engine rewrites the text. "balanced" preserves your structure and phrasing. "aggressive" runs our newest model, which rewrites the document from the ground up for maximum AI detection bypass. Aggressive accepts English input up to 4000 words and supports tone, purpose, writingDna, and the current advanced controls. Default-valued controls leave its tuned pipeline unchanged. The legacy "enableRestructure": true and "stealthMode": true flags still select aggressive.

writingDnastring

A natural-language paragraph (150-250 words) describing a personal writing style. When provided, the humanizer matches this voice instead of producing generic output. Generate it by analyzing 3-5 writing samples, or write it manually. Works with all other parameters.

keepMarkdownboolean= false

Preserve markdown formatting in the output. Enable when processing markdown content.

settingsobject

Fine-grained controls. Aggressive applies only values that differ from its defaults, including creativityLevel, lengthRatio, wordPreservation, semanticPreservation, styleMimicking, vocabularyRichness, sentenceVariation, technicalLevel, and idiomFrequency.

Settings Object

Optional fine-tuning parameters passed inside the settings field.

creativityLevelnumber= 70

Creative versus conservative rewriting (0-100).

vocabularyRichnessnumber= 65

Vocabulary variety and complexity (0-100).

sentenceVariationnumber= 60

Variation in sentence structure and rhythm (0-100).

contextualAwarenessnumber= 80

How strongly context is retained across the document (0-100).

regionalStylestring= "General"

Regional spelling and conventions: "General", "US", "UK", "AU", or "CA".

academicLevelstring= "General"

Academic reading level: "General", "High School", "Undergraduate", "Graduate", or "PhD".

technicalLevelnumber= 50

Density of field-specific technical language (0-100).

idiomFrequencynumber= 30

Frequency of idiomatic expressions (0-100).

lengthRationumber= 1

Target output length relative to input (0.5-1.5).

wordPreservationnumber= 40

Approximate percentage of source wording to retain (0-100).

semanticPreservationnumber= 85

How strictly the source meaning should be retained (0-100).

styleMimickingnumber= 75

How closely to match the source writing style (0-100).

frozenSentencesstring[]= []

Sentences to keep unchanged during humanization.

preserveQuotesboolean= true

Keep quoted text intact.

synonymVariationnumber= 50

Synonym replacement aggressiveness (0-100). Higher values produce more variation.

formalityLevelnumber= 50

Output formality (0-100). Lower is more casual, higher is more formal.

toneConsistencynumber= 75

How consistently the tone is applied (0-100).

preserveFormattingboolean= true

Maintain the original text structure and formatting.

preserveKeywordsstring[]= []

Specific words or phrases to keep unchanged.

maxLengthVariationnumber= 20

Maximum percentage the output length can vary from input (0-100).

Response Format

Streaming Response

NDJSON text chunks followed by an optional ai_score event when Beast Mode completes a detector check:

{"index":0,"original":"AI generated text.","paraphrased":"Natural sounding text.","type":"chunk"}
{"index":1,"original":"More content here.","paraphrased":"Additional content here.","type":"chunk"}
{"index":2,"original":"Final sentence.","paraphrased":"Last sentence.","type":"chunk"}
{"type":"ai_score","aiScore":3.8,"color":"text-green-500"}

Non-Streaming Response

Single JSON object with the full result and optional Beast Mode detector score:

{
  "content": "The fully humanized text output. Natural sounding text. Additional content here. Last sentence.",
  "aiScore": 3.8,
  "color": "text-green-500"
}

aiScore and color are included when beast_mode is enabled and the detector succeeds. Reuse this result instead of making a separate AI Score API request. The fields are omitted when Beast Mode is disabled. If detection is temporarily unavailable, you still get the humanized text: the stream ends with {"type":"ai_score_unavailable"} instead of an ai_score event, and the JSON response includes "aiScoreUnavailable": true. The score check is never billed separately, so an unavailable score costs nothing extra.

Examples

Non-Streaming Request

const response = await fetch("https://ryne.ai/api/humanizer/models/supernova", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    text: "Your AI-generated content goes here...",
    tone: "professional",
    purpose: "blog post",
    language: "english",
    user_id: "your_api_key",
    shouldStream: false,
    beast_mode: true,
    // Optional: pass a Writing DNA string to match a personal voice
    // writingDna: "Write in a style that uses short sentences, favors ...",
  }),
});

const data = await response.json();
console.log(data.content);
console.log(data.aiScore); // Final Beast Mode detector score, when available

Streaming Request

const response = await fetch("https://ryne.ai/api/humanizer/models/supernova", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    text: "Your AI-generated content goes here...",
    tone: "conversational",
    purpose: "article",
    user_id: "your_api_key",
    shouldStream: true,
    beast_mode: true,
    humanizerMode: "aggressive",
  }),
});

const reader = response.body.getReader();
const decoder = new TextDecoder();
let result = "";
let aiScore = null;
let buffer = "";

while (true) {
  const { done, value } = await reader.read();
  if (done) break;

  buffer += decoder.decode(value, { stream: true });
  const lines = buffer.split("\n");
  buffer = lines.pop();

  for (const line of lines) {
    if (!line.trim()) continue;
    const json = JSON.parse(line);
    // Chunks arrive in document order, so append them as they come.
    if (json.type === "error") throw new Error(json.message);
    if (json.type === "control" && json.action === "reset") {
      result = "";
      aiScore = null;
    } else if (json.type === "ai_score") {
      aiScore = json.aiScore;
    } else if (json.paraphrased) {
      result += json.paraphrased;
    }
  }
}

console.log(result);
console.log(aiScore); // Final Beast Mode detector score, when available

Modes and limits

Set humanizerMode in the request body. Both engines take tone, purpose and writingDna.

Balanced (default)

"balanced"
Keeps your structure and phrasing. Any supported language, though Beast Mode only checks English.

Aggressive

"aggressive"
Rewrites the whole document. English only, 4,000 units max. Beast Mode makes three attempts at most.
  • units = max(words, ceil(characters / 10)), counted per request.
  • {"type":"control","action":"reset"} mid-stream means drop what you've received.

To test it without writing code, paste a draft into the AI Humanizer.

Errors and rate limits

Failures return JSON with error: true and a readable error_msg. API keys have no daily rate limit; you can call until your credits run out.

StatusCodeMeaning
400INVALID_REQUESTBad JSON, empty text or wrong field type.
400noneAggressive got non-English text or over 4,000 units.
401AUTH_REQUIREDNo user_id in the body.
401noneBad key, or an account ID sent instead.
403INSUFFICIENT_COINSOut of API credits. Top up.
413INPUT_TOO_LARGEOver 40,000 characters. Split the text.

INSUFFICIENT_COINS shows up in status; every other code is in code. A 403 with no code means your header key doesn't match user_id. A stream that dies midway sends a {"type":"error",...} line. Retry 500s and 502s.

AI Score Checker API

Detect AI-generated content in real time. Get an overall confidence score, risk classification, and sentence-by-sentence breakdowns.

Request Parameters

All parameters are sent in the JSON request body.

textstringREQUIRED

The text to analyze for AI-generated content.

user_idstringREQUIRED

Your API key for authentication and billing.

Response Format

Example response
{
  "aiScore": 15.3,
  "classification": "HUMAN_ONLY",
  "details": {
    "classification": "HUMAN_ONLY",
    "confidence": 85,
    "analysis": {
      "type": "HUMAN_ONLY",
      "risk": "Low",
      "suggestion": "Text appears to be human-written"
    },
    "sentences": [
      {
        "text": "This is an example sentence.",
        "aiProbability": 12.5,
        "isAI": false
      },
      {
        "text": "Another sentence from the input.",
        "aiProbability": 18.1,
        "isAI": false
      }
    ]
  }
}
aiScorenumber

Overall AI probability score (0-100). Lower means more human-like.

classificationstring

One of "HUMAN_ONLY", "MIXED", or "AI_ONLY".

details.confidencenumber

Detection confidence level (0-100).

details.analysisobject

Contains type, risk ("Low"/"Medium"/"High"), and a human-readable suggestion.

details.sentencesarray

Per-sentence breakdown with individual AI probability scores.

Error Responses

StatusDescription
403Invalid API key or insufficient credits.
500Unexpected server error.

Examples

const response = await fetch("https://ryne.ai/api/ai-score", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    text: "The text you want to analyze for AI detection...",
    user_id: "your_api_key",
  }),
});

const data = await response.json();
console.log(data.aiScore);          // 15.3
console.log(data.classification);   // "HUMAN_ONLY"
console.log(data.details.sentences); // Per-sentence breakdown

AI humanizer API FAQ

Yes. POST your text to https://ryne.ai/api/humanizer/models/supernova with your ryne_sk_ key as user_id, and the rewrite comes back as JSON.

$0.08 per 1,000 words, so a dollar covers about 12,500. Prepaid top-ups start at $5 and there's no subscription. Volume pricing: business@ryne.ai.

40,000 characters per request. You're billed in units: your word count or characters ÷ 10, whichever is higher. Aggressive takes English only, up to 4,000 units.

Yes, by default. Each line is its own JSON object. Beast Mode adds an ai_score line at the end when the detector returns a score. Send shouldStream: false for one response.

No. If a request fails before any text comes back, the credits go back to your balance.

Need help?

Our developer support team is ready to help you integrate.

Contact developer support