Humanizer API: Preserve Citations, Links and Tables

StealthGPT’s humanizer API can rewrite editable prose while you keep verified document content fixed. In our November 7, 2026 live integration test, all 90 explicit markers across five protected calls returned byte-for-byte in the original order. Our client then restored the original citations, quotations, links, headings, tables and HTML tags from its own span map.

For publishing systems, academic editing tools and AI agents, this creates a practical division of work: choose what must remain exact, humanize the prose around it, then validate the assembled document before it enters your publishing workflow. The downloadable evidence includes every request and output from all six calls, including the unprotected control and the cases that required correction.

The live result: 90 of 90 explicit markers preserved

We tested three original synthetic documents through the production POST /api/stealthify endpoint: a Markdown research brief, an HTML agency publishing brief and a plain-text academic-methods example. Every call used Super in quality mode. The five protected calls used preservation: true and preservationMode: "inline". All six calls returned HTTP 200; none of the protected responses reported a fallback.

Both protected HTML outputs retained the original tag sequence and attributes. The protected Markdown outputs retained the selected heading hierarchy, table, source citation, quotation and link. These are exact checks against the supplied originals, with raw files and SHA-256 hashes available for inspection.

The six calls charged 7,036 prepaid credits with zero additional metered charged credits. The complete factual-lock requests processed much less editable prose, so their lower recorded times and credits describe those requests rather than an equal-work speed comparison.

How the preservation workflow works

The text-preservation API keeps explicit markers such as [[F1]] unchanged. Your application replaces each protected original span with a unique marker before sending the request, then swaps its own original content back into the result. You choose the protected spans; the API holds their markers in position while the surrounding text is humanized.

• Structure: freeze HTML tags and attributes, Markdown headings, tables, lists and complete FAQ blocks when their wording or layout must remain exact.

• Evidence: freeze a complete quotation with its attribution, the full citation and the original link destination.

• Facts: freeze the whole statement that connects a number to its subject, units, timing and meaning. For example, protect the complete sample-size sentence rather than only the number 48.

This approach gives your application control over what changes. A citation-rich paragraph, an approved offer or a signed-off FAQ can stay exactly as supplied while the introduction, transitions and explanatory prose receive a rewrite.

Why we moved from isolated fields to complete factual locks

The first protected Markdown call kept all 15 selected markers intact, but the editable prose added an unsupported “fall of 2005” memo date. The first HTML call kept all 29 markers intact while changing the fictional agency’s role into invented StealthGPT service commitments. Exact strings survived; the meaning around them still needed validation.

We then made one deliberate workflow adjustment on each of those same sources: lock complete factual sentences, the subject and role, the synthetic-material disclaimer, and whole FAQ question-and-answer blocks. These two additional requests used different protection scopes. We retained all six outcomes in the evidence pack rather than replace the earlier results.

The factual-lock outputs retained those full source-of-truth statements exactly, and the unsupported date and invented service commitments were absent. The remaining editorial review still mattered: an editable HTML instruction changed from verifying an offer before scheduling to checking it before publishing. Our claim review records that timing change instead of treating intact markers as complete factual approval.

The unprotected control shows what the locks protect

We sent the same Markdown source once without marker preservation. It kept only 7 of the 15 selected exact strings or blocks. The source citation and source link disappeared, heading levels changed, and the table’s formatting changed even though its cell values remained. That selected-span count is an integration check, not a writing-quality score.

The practical use is clear: if a publishing system needs a citation, link, table or approved answer to survive exactly, make that requirement explicit in the request workflow.

An actual before-and-after example

The factual-lock Markdown request kept its study design, results, citation, quotation, table and FAQs fixed. This short passage remained editable. The following text is copied directly from the saved source and actual API output.

Original editable passage

          The next study should use a larger sample and record how rooms are allocated before making a broader recommendation. It should also separate satisfaction from any measure of learning.
        

Actual Super quality output

          Future studies would benefit from a larger sample size and data collection on room assignment before more sweeping conclusions are recommended. Finally, it’s important to keep student satisfaction separate from any metric of learning.
        

The output changes the prose while the locked factual paragraphs remain exactly as the application supplied them. The download contains the complete source, marked request, raw marked output and restored Markdown, so the example can be checked in context.

Build the workflow in five steps

1. Choose source-of-truth spans. Identify the approved facts, citations, quotations, links and structural blocks that must not change. Preserve complete statements when their relationship matters.

2. Create a unique marker map. Replace each selected span with one marker and keep the original value in your application. Put heading and block markers on their own line where practical.

3. Humanize the marked source. Send only the source text in prompt, with rephrase: true, an explicit model, quality mode and preservation enabled.

4. Validate and restore. Require every expected marker once and in order. Restore the originals, then check headings, table blocks, HTML structure, link destinations and numeric changes.

5. Review the editable prose before publishing. Compare subjects, obligations, timing, negation and uncertainty with the source. Send an output requiring correction to your editing stage rather than straight to publication.

Runnable Node.js example

Extract the evidence pack and use its factual-lock-fixtures.json file. The example below runs the recorded Markdown factual-lock request with your own API key supplied through the environment. The pack also includes a bounded runner with attempt logging, saved receipts and no automatic retries.

          import fs from 'node:fs';

const key = process.env.STEALTHGPT_API_KEY;
if (!key) throw new Error('Set STEALTHGPT_API_KEY securely');
const fixture = JSON.parse(
  fs.readFileSync('./factual-lock-fixtures.json', 'utf8')
)[0];

const response = await fetch('https://www.stealthgpt.ai/api/stealthify', {
  method: 'POST',
  signal: AbortSignal.timeout(360_000),
  headers: { 'api-token': key, 'Content-Type': 'application/json' },
  body: JSON.stringify({
    prompt: fixture.markedInput,
    rephrase: true,
    model: 'super',
    qualityMode: 'quality',
    outputFormat: 'markdown',
    preservation: true,
    preservationMode: 'inline'
  })
});
const data = await response.json();
if (!response.ok || typeof data.result !== 'string') {
  throw new Error(`Request failed: ${response.status}`);
}

const expected = fixture.markerMap.map(item => item.marker);
const returned = data.result.match(/\[\[[^\]]{1,10}\]\]/g) ?? [];
if (JSON.stringify(expected) !== JSON.stringify(returned)) {
  throw new Error('Marker validation failed');
}
const restored = fixture.markerMap.reduce(
  (text, item) => text.split(item.marker).join(item.span),
  data.result
);
fs.writeFileSync('./rewritten-for-review.md', restored);
// Run structural and factual checks before publishing.
        

For a full integration, use the API reference and asynchronous runs when your application needs a job-based flow. This six-call test used the synchronous endpoint.

Download the complete API evidence pack

The public pack contains all three original documents, both masking strategies, all six exact request bodies, recorded responses, raw and restored outputs, deterministic checks, the 61-claim editorial review, reproduction scripts and file hashes. Authentication headers and account balances are omitted. Download the complete API evidence pack.

This is first-party integration evidence from StealthGPT, collected on November 7, 2026 Pacific time. The documents are synthetic fixtures, and the semantic review is unblinded and AI-assisted. This test measures explicit document preservation; it does not include external detector scans, Turnitin reports or customer outcome claims. The historical internal score field in raw API responses is excluded from the published results.

Frequently asked questions

Can the humanizer API preserve citations and quotations?

Yes. Replace the full citation or quotation-and-attribution span with a unique marker, enable preservation and restore the original span afterward. Protect the full factual statement too when its wording, role or scope needs to remain fixed.

Can it preserve HTML links, tables and Markdown headings?

Yes, through explicit caller-side tokenization. Our protected HTML tests retained the original tag sequence and attributes, and the protected Markdown tests retained the selected headings, table and link exactly. The application decides which tags or complete blocks to freeze.

Which humanizer model was used?

These requests used Super in quality mode. For examples across all three models, see the Super vs Standard vs Lite comparison.

Are the protected original spans sent as editable prose?

No. Your application stores those spans and sends their markers instead. It restores the originals after receiving the result. See API pricing for current usage accounting.

Put document preservation into your publishing pipeline

Use StealthAPI to add humanization to your editor, publishing system or agent workflow. Start with a source-of-truth span map and a validation stage, then expand the editable prose your application can confidently review. For a deployed publishing workflow, read the StudySim API case study. For student editing through the app, explore the AI Humanizer.