canonical: https://jentic.com/apis/hastewire.com/hastewire

# Hastewire API

The Hastewire API rewrites AI-generated text to read more naturally and scores text for how AI-written it looks. An agent sends a block of text to the humanize operation and gets a reworked version back, or sends text to the detect operation for an AI-likelihood assessment. It also exposes the account behind the API key, billed usage, and a service status check, so an agent can track consumption and confirm the service is up before a batch.

## For AI agents

Humanize AI-generated text, detect how AI-written a passage is, and read the account and its billed usage.

## Scope

Does not handle translation, grammar correction, or generating text from a prompt. Use for humanizing AI text and detecting AI-written content only.

## Capabilities

- Humanize a block of AI-generated text into a more natural version
- Detect how AI-written a passage of text appears
- Read the account behind the API key
- Read billed usage for the account
- Check the service status before running a batch

## Use cases

### Humanize Then Detect

An agent reworks AI-generated copy and verifies the result. It sends the draft to the humanize operation, takes the reworked text, then sends that text to the detect operation to score how AI-written it still reads. Because humanize and detect are separate operations, the agent can loop: rewrite, re-score, and stop when the detection score is low enough.

Example prompt: Send an AI-generated draft to the humanize operation, then send the result to the detect operation and return both the text and its score

### Content Pipeline Gate

An agent gates a publishing pipeline on an AI-likelihood check. It runs the detect operation on each draft and only lets passages below a chosen threshold through, routing the rest back to be humanized. This gives an editorial workflow an automated check without a human reading every draft first.

Example prompt: Run the detect operation on a draft and return whether its AI-likelihood score is above or below a given threshold

### Usage-Aware Batches

An agent keeps a humanizing batch within budget. It reads billed usage and the account before a run, confirms the service status, then processes drafts while watching consumption. Because usage is its own endpoint, a scheduled agent can pause itself when it nears a limit rather than failing mid-batch.

Example prompt: Read billed usage and service status, then humanize a batch of drafts only while usage stays within budget

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/api/v1/humanize` | Humanize AI-generated text |
| POST | `/api/v1/detect` | Detect AI-generated text |
| GET | `/api/v1/status` | Check the service status |
| GET | `/api/v1/me` | Read the account behind the API key |
| GET | `/api/v1/usage` | Read billed usage for the account |

## Key resources

- **Humanize** — Rework AI-generated text into a more natural version
- **Detect** — Score how AI-written a passage of text appears
- **Account** — Read the account behind the API key
- **Usage** — Read billed usage for the account
- **Status** — Check the service status

## AI readiness

This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.

- **Score:** 66 / 100
- **Maturity:** AI-Aware
- **Dimensions:**
  - Foundational Compliance: 85 / 100
  - Developer Experience & Jentic Compatibility: 65 / 100
  - AI-Readiness & Agent Experience: 46 / 100
  - Agent Usability: 94 / 100
  - Security: 60 / 100
  - AI Discoverability: 93 / 100
- **View full report:** https://jentic.com/apis/hastewire.com/hastewire/scorecard
- **How the score is calculated:** https://docs.jentic.com/reference/api-readiness-framework/overview/
- **More about the dimensions:** https://docs.jentic.com/reference/api-readiness-framework/specification/#dimensional-model-overview

### Score it yourself

Every API in the directory is allowlisted, so you can re-score it with no key required.

- **Score your own API:** https://jentic.com/scorecard.md
- **Scoring CLI agent skill:** https://github.com/jentic/jentic-api-scorecard/blob/main/skills/jentic-api-scorecard/SKILL.md

```sh
npx @jentic/api-scorecard-cli score <openapi-url>
```

## Why Jentic

- **Setup:** Wiring Hastewire by hand means handling its bearer API key, tracking prepaid credit usage, and checking service status before a batch. Through Jentic you install once, import Hastewire from the API Directory, store the key once, and your agent calls it.
- **Permission scoping:** Hastewire sends the text to process in the request body, not the URL, so a rule bounds which operations your agent may call rather than which text it touches. You choose the operations it may use, such as humanize and usage, so the detect operation stays off until you add it.
- **Credential handling:** Your Hastewire API key is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'humanize AI text' or 'detect AI writing', and Jentic returns the matching Hastewire operation with its input schema so the agent calls the right endpoint without reading the reference docs.

## Related APIs

- **Cohere** — Cohere's language models can rewrite and rephrase text as a general-purpose alternative.
- **Mistral** — Mistral offers language models that can paraphrase and restyle text from a prompt.
- **OpenAI** — OpenAI generates the drafts that Hastewire then humanizes and scores.

## FAQ

### What authentication does the Hastewire API use?

Per its OpenAPI spec, the Hastewire API authenticates with a bearer API key in the Authorization header, while the service-status endpoint is open. Through Jentic the key is stored by your own self-hosted instance and injected when the agent calls the humanize, detect, account, or usage operations, so it never appears in the agent's prompt or logs.

### Can I humanize and detect AI text with the Hastewire API?

Yes. The humanize operation reworks a block of AI-generated text into a more natural version, and the detect operation scores how AI-written a passage appears. An agent can chain them: humanize a draft, then run detect on the result to check the score, and repeat until it is satisfied.

### What are the rate limits for the Hastewire API?

The OpenAPI spec does not state a numeric rate limit; requests are billed in prepaid credits, and the usage endpoint lets an agent track its own consumption. Add backoff around 429 responses, and check the Hastewire documentation at https://hastewire.com for current limits and pricing.

### Can I limit what my agent is allowed to do with the Hastewire API?

Yes. Hastewire sends the text to process in the request body rather than in the URL, so a rule bounds which operations your agent may call, such as humanize and detect, not which text it processes. You choose that it may humanize and read usage while the detect operation stays off until you add it, and every call it makes is logged.

### Is there a Hastewire MCP server?

You do not need an MCP server to give your agent the Hastewire API. Jentic connects it directly from the Jentic API Directory: import Hastewire, store your API key once, and your agent calls the humanize and detect operations on demand without loading another server's tool definitions into its context.

### How do I humanize text with the Hastewire API through Jentic?

Search Jentic by intent such as 'humanize AI-generated text', and Jentic returns the Hastewire humanize operation with its input schema so the agent sends the right text. To run it on your own infrastructure, install Jentic One from its GitHub repo with `curl -fsSL https://raw.githubusercontent.com/jentic/jentic-one/main/tools/install.sh | sh`, then add Hastewire from the directory.
