Convert to UTF-8
Text that reads "Café del Mar" instead of "Café del Mar" has not lost its data — it was UTF-8 that got read as Latin-1 or Windows-1252, and each accented letter split into two stray symbols. Paste the affected text and this tool reverses that specific corruption, returning the original characters as clean UTF-8.
Run — free
Where this mojibake comes from
Text doesn't carry a label saying which encoding it was saved in, so a program has to assume one. The single most common mismatch is UTF-8 content read as Latin-1 or Windows-1252: it doesn't error out, it just silently turns every accented letter, curly quote or non-Latin character into a short run of odd symbols — "é" becomes "é", "’" becomes "’" — because the same bytes map to different symbols in each encoding.
What the fix actually does
Paste the garbled text and the tool reverses exactly that one corruption: it maps the stray symbols back to the bytes they came from and re-reads them as UTF-8, then returns the repaired text normalized to NFC. Because the mangling is reversible, it recovers the original characters of any language — French, Japanese, Arabic — as long as the corruption is this Latin-1/Windows-1252 misread. It is not a general encoding converter: it does not identify arbitrary source encodings, and it does not convert text stored in Shift-JIS, GBK or other East Asian encodings, nor recover characters already replaced by question marks.
How the request and pricing work
Send the text to /data/to-utf8 and the call returns a task_id, then delivers the repaired UTF-8 text to your signed webhook or through a signed link valid for 24 hours. Pricing is a flat $0.002 per request, and a job that fails after three retries is never billed. The tool above does the same repair free in your browser — nothing is sent to a server.
Why UTF-8 is the answer, not just an option
UTF-8 became the dominant encoding on the web precisely because it can represent every character in the Unicode standard while staying backward-compatible with plain ASCII, which is why modern browsers, databases and APIs default to it. Getting text back into clean UTF-8 is what makes it portable across every system it might touch next, instead of splitting into symbols the moment it moves.
Where it fits in automation
This kind of mojibake tends to surface at the worst possible time, deep inside a pipeline that assumed clean input, so the repair belongs right where text arrives: right after a paste, an import, or an old record is pulled up, and before anything parses or displays it. API access requires prepaid balance, which keeps requests fast and the service abuse-free. This endpoint is live now.
What you can do with it
Rescuing pasted rows from an old export
A data team pastes the broken rows of a decade-old CSV export that show "é"-style garble and gets clean UTF-8 text back before loading it into a modern analytics pipeline.
Cleaning up submitted content
A publishing platform runs incoming article text that arrived with Latin-1/Windows-1252 mojibake through the repair so it lands in the CMS with the accented characters intact.
Fixing a previous bad conversion
A support team pastes text that was mangled when UTF-8 was read as Windows-1252, recovering the original accented and special characters instead of leaving them garbled.
Legacy system cleanup
An IT team pipes text pulled from a retiring Windows-1252 based system through the repair to fix the mojibake before storing it as UTF-8.
FAQ
How do I fix mojibake with an API?
Send the affected text to /data/to-utf8. The call returns a task_id right away and delivers the repaired UTF-8 text to your webhook or a signed link once processing finishes.
Is this API free to use?
The tool above runs free in your browser. The API is paid — each call draws from your prepaid ForHosting KIT balance: top up from $10.00 (it never expires), pay each request's published price, and a call with no balance returns HTTP 402. No subscription, no tokens, and a failed task is never charged.
What is mojibake and can this fix it?
Mojibake is the garbled text that appears when a file is decoded with the wrong encoding. This tool reverses the common Latin-1/Windows-1252 case — the "é" pattern — recovering the intended characters.
Which corruption does it handle?
The specific Latin-1/Windows-1252 misread of UTF-8 — the "é", "’", "ع" style garble — for text of any language. It leaves already-valid UTF-8 untouched. It does not identify arbitrary encodings or convert Shift-JIS, GBK or similar, and it cannot recover characters already turned into question marks.
Do I paste text or upload a file?
You paste the affected text (a snippet from a file is fine); the tool works on the text you send, not on an uploaded file, so copy in the garbled rows and read the repaired text back.
Can I process many pieces of text in bulk?
Yes, each piece is submitted as its own request and processed independently, so a batch can be handled in parallel with results delivered by webhook as each finishes.
Is the Encoding Repair API live now?
Yes, this endpoint is live today at the published price of $0.002 per request.
What happens to my text after the repair?
Submitted text and the repaired output are deleted after the retention window and are never used for training. Delivery is by signed webhook or a signed link valid for 24 hours.
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/data/to-utf8 \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"café"}'const res = await fetch("https://api.kit.forhosting.com/data/to-utf8", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "café"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/data/to-utf8",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "café"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/data/to-utf8", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"café"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"café"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/data/to-utf8", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"text": "café"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "data.to_utf8",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Limits
max_mb | 25 |
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |