ForHosting KIT · Translation

Translate a Word document

A translated Word file that comes back as flat text isn't a translated file — it's a rewrite job waiting to happen. This endpoint keeps the styles, the heading levels and the tables where they are, so the document you get back is the one you can still edit, not a copy you have to rebuild from scratch.

Temporarily withdrawnPer request + per page$0.057

This task is not available right now, so it cannot be purchased. Nothing is charged for it.

How it works & API

Use it from WebAPIEmailApp soonTelegram soon

Why the .docx format itself is the hard part

A DOCX file isn't really a document; it's a small zip archive of XML parts describing text runs, style references, table grids and section breaks all pointing at each other. Translate the visible words without respecting that structure and you get a file that opens with broken numbering, styles that no longer apply, or a table where three cells silently vanished. Anyone who has proposal templates, style guides bound into Heading 1/Heading 2 hierarchies, or contracts with numbered clauses knows exactly how much that structure is worth — and how annoying it is to lose.

What the endpoint is built to do

POST /translate/docx with the source file and target language and it returns a task_id right away while translation happens in the background — the same asynchronous pattern used across the API, so long documents don't tie up a connection. The intent is to walk the document's own structure: translate each text run in place, leave style references, table layout and section breaks untouched, and hand back a .docx that still opens cleanly in any standard word processor with formatting intact.

Where this fits next to PDF translation

PDF is a fixed, print-accurate snapshot — right for a signed contract or a filed form that must never change. DOCX is the opposite: it's meant to keep being edited, reviewed with tracked changes, and reused as a template. Translating a DOCX and getting a DOCX back matters most for exactly that reason — a translated proposal, contract draft or internal policy that someone still needs to revise, comment on, or merge with local legal language after translation, not just read.

Current status and what to expect

translate.docx is in deployment: the pricing is set at $0.057 per request plus $0.016 per page, and the endpoint is not yet accepting production jobs. Once it opens, the same task_id, webhook and 24-hour signed link pattern used across the rest of the API applies here too, so integrations that already call other translation endpoints won't need new plumbing — just point them at /translate/docx when it goes live and it slots into whatever pipeline already handles document translation.

What you can do with it

Proposal templates for new markets

A sales team plans to translate its Word proposal template into a new market's language while keeping headings, tables and branding styles intact for reuse.

Editable contract drafts

A legal team wants a translated contract that still opens as an editable DOCX, so local counsel can add clauses with tracked changes after translation.

Internal policy documents

An HR department intends to translate multi-section policy manuals with numbered headings and keep that numbering intact in every language version.

Bilingual documentation pipelines

A software company plans to feed its Word-based release notes through automated translation as part of a documentation build step.

FAQ

How will I translate a Word document with the API?

POST the DOCX file and target language to /translate/docx, save the returned task_id, and retrieve the translated DOCX by webhook or a signed link valid for 24 hours, once the endpoint opens.

Is the Word translation API free?

No, there is no free tier or trial; pricing is set at $0.057 per request plus $0.016 per page, and a failed translation is never charged.

Does the translated DOCX stay editable?

Yes, that's the point of the endpoint — it works at the document's structural level so styles, headings and tables remain intact and editable, not flattened into plain text.

Is /translate/docx live right now?

Not yet — it's in deployment and not accepting jobs at this moment; check the endpoint status before pointing production traffic at it.

Will this preserve tables and numbered headings?

Yes, the design translates text runs while leaving table layout and heading styles untouched, so numbering and structure carry over.

How is the price calculated?

It's a flat per-request fee plus a per-page rate based on the document's length, the same predictable model used across the translation endpoints.

Can I batch-translate many Word files?

Yes, the plan is one asynchronous task per file with results collected by webhook, which is how batch runs work across the API.

Is my Word document stored after translation?

No, source and translated files will be deleted after the retention window and are never used for training.

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

POSThttps://api.kit.forhosting.com/translate/docx

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, and soon from our app, email and Telegram.

Call it from your stack

curl -X POST https://api.kit.forhosting.com/translate/docx \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d &#39;{"input":"…"}'

const res = await fetch("https://api.kit.forhosting.com/translate/docx", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "input": "…"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/translate/docx",
    headers={"Authorization": f"Bearer {os.environ[&#39;KIT_KEY']}"},
    json={
    "input": "…"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/translate/docx", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => &#39;{"input":"…"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"input":"…"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/translate/docx", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "input": "…"
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "translate.docx",
  "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

Per request$0.057

Per page$0.016

Published price — no tokens, no invented credits. A failed task is never charged.

Limits

max_tokens 20000

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.
`413`	`input_too_large`	The file exceeds the size limit.
`422`	`task_failed`	The task failed after 3 retries. You are never charged for it.

Read the full KIT documentation →