declaude: a Claude humanizer for drafts that still read like the model

You employed Claude to produce an initial draft. The structure is sound and the facts are correct, yet the text has an AI-like tone. It includes an em dash in each paragraph, a "not just X, but Y" pattern in the second, and a three-item list where a human would normally use two. Regular readers of AI-generated text will spot these patterns quickly. When readers detect that the source is AI, they concentrate on the model rather than your message. declaude.org provides a free Claude humanizer intended to correct these particular drafting problems. This guide describes how the tool modifies your wording, how it deals with the statistical watermarks in newer Claude models, and how to operate it via the browser or the API.

A Claude humanizer is a tool that takes a draft written by Claude and returns it as plain prose, with the model's habits removed and the argument intact. declaude.org does this for free in the browser and through a paid API, and it is unusually clear about what it can and cannot do to the text watermark.

Why the register costs more than the draft saved

Using a model to convert a blank page into a draft you can later refine is acceptable. We employ this approach. The problem lies in the particular quality of prose the model generates during that step.

Each AI-assisted draft contains a register. Significance inflation ("a testament to"), performed insight ("here's the thing"), the paragraph that ends on a punchline, and the sentence that hedges when it should commit are not spelling mistakes. Each of these signals to the reader that no one with a point of view reviewed the piece before it was released.

That represents the cost. Our main argument is that only writing that no other person could have produced is worth publishing, and a draft that sounds like the model sounds like anyone.

What a Claude humanizer does, and what this tool does not claim to do

declaude is a free tool provided by NOPE, the company that creates detection instruments for AI conversations. You insert text into the tool and get the same content returned as plain prose. It rewrites according to the meaning of the text rather than swapping synonyms, thereby eliminating specific patterns together with the sentences that held them.

Most tools advertised as AI humanizers aim to bypass detection software. declaude, however, is built to remove the register. The objective is to create a draft that resembles your own writing rather than one meant to deceive a scoring website. This tool does the same job as the Humanizer skill on GitHub, but it is provided as a hosted editor and an API. This enables it to operate within an automated pipeline or as a standalone browser tab.

The tool computes a score during processing. It measures a tic rate per 1,000 words, referred to as claude_load. Data from declaude shows that typical human writing scores about 1.5, whereas texts with many tics in its evaluation set score near 16. Since you see the score before and after, you can tell whether a text needed only minor tweaks or a full rewrite.

A text watermark does not reside in characters or metadata. It is present in the choice of words. When multiple words are possible, a secret key gives priority to a particular set. Someone possessing the key can then assess how often those prioritised words occur. Google has watermarked Gemini text since 2024. According to the Anthropic help centre, the Claude watermark has been applied at the model level in new models since August 2026. The website declaude.org/watermarking offers a visual guide that explains this process more clearly than a written description.

The operation of the mark produces three specific outcomes. declaude outlines each of them clearly:

• Only the holder of the key can verify its presence. Anthropic currently offers detection only to eligible organisations under EU law, such as regulators, media, and fact-checkers. Your editor and the "AI detector" websites cannot perform the test; they infer from style, which relates to the register issue mentioned earlier, not the watermark.
• The mark persists through light editing but disappears after re-composition. Correcting typos and tightening a few sentences leaves most of the word runs the detector counts intact. Rewriting based on meaning removes them. In open watermarking schemes that the team could measure, a full rewrite reduced detection to a coin flip. Anthropic's own announcement says much the same: light editing probably won't remove the mark completely, and a complete rewrite where every word is replaced will.
• Nobody outside Anthropic can test that claim against Claude's own mark, since the key is private and detection is not open to the public. The tool states this on the page. That is the honesty you want from anyone making this kind of claim.

Anthropic's documentation also states that the mark shows Claude processed the text, not that Claude wrote it: human text that Claude only proofread also acquires it. The honest use of such a tool is to ensure that a draft you have reshaped into your own argument reads as yours, and to understand what any remaining signal indicates. If a client or a publication requests disclosure of AI assistance, disclose it; a rewriter alters the prose, not the answer to that question.

Using the web editor

The browser tool at declaude.org serves as the appropriate starting point. It is enough for most articles.

1. Paste your draft into the text box. If you wish to see it operate before trusting it with your own words, a sample is provided.
2. Choose whether to enable paranoid mode. The default pass removes the register while preserving as much of your wording as possible. Paranoid mode rewrites everything and performs a second pass. It runs slower and retains slightly less of the original phrasing, which is intended if you aim for re-composition rather than a simple tidy-up.
3. Press "declaude it" and wait. The pipeline performs real work: roughly 15 to 20 seconds for 500 words, and more time for a full article.
4. Compare the output to the original. The tool displays every change, allowing you to spot a claim it simplified, a client name it altered, or a number it repositioned.
5. Copy the result before closing the tab. Results are only available in that browser tab. Closing the tab will cause them to be lost.

This is the privacy model, applying to both the free tool and the API: the text is never logged or stored. declaude keeps only metadata (word counts, processing time, and a daily-rotating hash of the requesting IP address).

The editor has one notable limitation. If you need to process a large volume of text or prefer the process to run within a workflow rather than a browser tab, you should use the API.

Using the declaude API in a content pipeline

If you already review drafts via a Slack bot, a CMS hook, or a batch job before a newsletter is sent, you can add declaude as one HTTP call to humanize Claude text before a person reads it. You generate keys in your account after signing in through an emailed link. Credits are prepaid and charged per request. The tool does not charge for requests that return your text unchanged.

A single endpoint handles this task:

curl https://declaude.org/api/v1/declaude \
  -H "Authorization: Bearer declaude_live_..." \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{
    "text": "It is important to note that this is, at its core, a test.",
    "depth": "standard"
  }'

The request takes three fields. The text field holds the draft and is limited to 6,000 words. The depth field specifies how extensive the changes will be. The light setting applies minimal edits to adjust the register. The standard setting is the default option. The thorough setting carries out a deeper rewrite and costs more. It has a lower ceiling of 4,000 words because it processes the text in a single pass with a fixed output budget. The preserve_clean field is optional and is off by default. If you set it to true, the tool will leave unchanged sections that lack AI characteristics. This also applies under the thorough setting, which normally reworks sections that are already clean.

Two design decisions save you money. Unknown fields are rejected rather than ignored, so a typo such as preserveWording results in a 400 error instead of quietly billing you for a request that did something else. If you request thorough and the deeper pass fails its quality guard, the response's depth_applied field indicates what actually ran.

The response looks like this:

{
  "request_id": "b1e7...",
  "status": "ok",
  "text": "This is a test.",
  "text_retained": true,
  "before": { "claude_load": 15.9, "band": "very_high", "band_label": "very claude-y" },
  "after":  { "claude_load": 1.2,  "band": "human",     "band_label": "within the human band" },
  "report": { "verbatim_overlap": 0.006, "length_ratio": 0.98, "depth_applied": "standard" },
  "usage":  { "words_in": 12, "words_out": 4 }
}

Your quality checks should include several fields. Base the evaluation on the band field, which may be human, mild, high, very_high, or unscored, and avoid using the band_label field because maintainers will update it. verbatim_overlap indicates the proportion of original eight-word sequences that stay unchanged. Treat this as a measure of how much rewording occurred rather than a quality metric, and a lower value usually shows successful rewriting. length_ratio flags cases where the rewrite considerably shortened the original text. claude_load returns a null value and sets band to unscored when the input text is too short to be scored.

Retries, idempotency, and two common problems

Sending an Idempotency-Key header, which can be any string of 1 to 128 characters composed of letters, digits, periods, underscores, colons, or hyphens, ensures that the same request is not charged more than once. Since no text is stored, repeated requests are handled from memory for ten minutes. After ten minutes the request still returns with metering information, but the text field will be null and the text_retained field will be false. Check the text_retained field rather than assuming the text is present.

Errors are returned in the format {"error": "<code>", "message": "<sentence>"}. Use the code for branching logic because codes remain stable while messages can change. The following are the codes you will need to handle:

Two common problems that affect users are the read timeout and the pipeline error. Rewrites are performed synchronously. A request containing 6,000 words may take a couple of minutes to finish. You ought to set your client's read timeout to 300 seconds. The httpx default is five seconds, which can cause failures for long documents. The pipeline_error is the sole situation that needs a new idempotency key.

Below is the structure of a client that handles both problems, based on declaude's reference integration:

import os, time, uuid, httpx

def declaude(text, depth="standard"):
    key = str(uuid.uuid4())  # one key per submission, reused on retry
    with httpx.Client(timeout=300) as c:
        for attempt in range(5):
            r = c.post(
                "https://declaude.org/api/v1/declaude",
                headers={"Authorization": f"Bearer {os.environ['DECLAUDE_KEY']}",
                         "Idempotency-Key": key},
                json={"text": text, "depth": depth},
            )
            if r.status_code == 200:
                body = r.json()
                if not body["text_retained"]:
                    raise RuntimeError("result no longer available; use a new key")
                return body["text"]

            err = r.json()
            if r.status_code in (409, 429, 503):
                time.sleep(int(r.headers.get("Retry-After", 2)))
                continue
            if err["error"] == "pipeline_error":
                key = str(uuid.uuid4())
                continue
            raise RuntimeError(f"{err['error']}: {err['message']}")
        raise RuntimeError("gave up after 5 attempts")

Before running a batch, call GET /api/v1/account using the same bearer token. It is free and authoritative; it validates the key, returns your balance and daily budget, and lists your limits (word ceilings for each depth and the concurrency cap, which is two requests in flight per key). Compare it to the size of tonight's queue instead of discovering the issue at request 40.

The function of this tool in the process

declaude removes a register. It does not introduce a perspective, and it cannot assess the validity of an argument.

Run the tool after completing your draft but before the final review. Do not treat it as a substitute for those steps. Follow this order: write or generate the draft, revise it until it presents a single position you are prepared to defend, run the declaude tool, and then read the text aloud. During the final reading, carry out two specific tests. First, attempt to swap the positions of two body paragraphs. If the text still works, you have a list of points rather than a cohesive argument. Second, identify the specific new fact that each paragraph provides. If a paragraph does not contribute a new fact, delete it.

If you are using a model for content or document workflows and the drafts are acceptable but do not fit your specific style, the usual solution is to add a review step to the workflow rather than writing a better prompt. We design AI workflow automation that employs governed data and maintains human oversight at the appropriate stages. Contact us to discuss these services.

Frequently asked questions