diff --git a/README.md b/README.md
index 8b9bcd6..82cc944 100644
--- a/README.md
+++ b/README.md
@@ -15,7 +15,7 @@
 
 ---
 
-`kagi` is a terminal CLI for Kagi that gives you command-line access to search, lenses, ask-page, assistant, summarization, feeds, and paid API commands. it is built for people who want one command surface for interactive use, shell workflows, and structured JSON output.
+`kagi` is a terminal CLI for Kagi that gives you command-line access to search, lenses, ask-page, assistant, translate, summarization, feeds, and paid API commands. it is built for people who want one command surface for interactive use, shell workflows, and structured JSON output.
 
 the main setup path is your existing Kagi session-link URL. paste it into `kagi auth set --session-token` and the CLI extracts the token for you. if you also use Kagi's paid API, add `KAGI_API_TOKEN` and the public API commands are available too.
 
@@ -29,7 +29,7 @@ if you already use Kagi and want to access it from scripts, shell workflows, or
 
 - use your existing session-link URL for subscriber features
 - get structured JSON for scripts, agents, and other tooling
-- use one CLI for search, assistant, summarization, and feeds
+- use one CLI for search, assistant, translate, summarization, and feeds
 - add `KAGI_API_TOKEN` only when you want the paid public API commands
 
 ## quickstart
@@ -101,7 +101,7 @@ export KAGI_API_TOKEN='...'
 
 | credential | what it unlocks |
 | --- | --- |
-| `KAGI_SESSION_TOKEN` | base search fallback, `search --lens`, filtered search, `ask-page`, `assistant`, `summarize --subscriber` |
+| `KAGI_SESSION_TOKEN` | base search fallback, `search --lens`, filtered search, `ask-page`, `assistant`, `translate`, `summarize --subscriber` |
 | `KAGI_API_TOKEN` | public `summarize`, `fastgpt`, `enrich web`, `enrich news` |
 | none | `news`, `smallweb`, `auth status`, `--help` |
 
@@ -140,6 +140,7 @@ for the full command-to-token matrix, use the [`auth-matrix`](https://kagi.micr.
 | `kagi news` | read Kagi News from public JSON endpoints |
 | `kagi assistant` | prompt Kagi Assistant, continue threads, and manage thread list/export/delete with a subscriber session token |
 | `kagi ask-page` | ask Kagi Assistant about a specific web page |
+| `kagi translate` | translate text through Kagi Translate with a subscriber session token |
 | `kagi fastgpt` | query FastGPT through the paid API |
 | `kagi enrich` | query Kagi's web and news enrichment indexes |
 | `kagi smallweb` | fetch the Kagi Small Web feed |
@@ -220,6 +221,26 @@ kagi assistant thread list
 kagi assistant thread export <THREAD_ID>
 ```
 
+translate text and keep all text-mode extras:
+
+```bash
+kagi translate "Bonjour tout le monde"
+```
+
+plain `kagi translate "..."` means `--from auto --to en`.
+
+translate to a specific target language:
+
+```bash
+kagi translate "Bonjour tout le monde" --to ja
+```
+
+translate only the core text result:
+
+```bash
+kagi translate "Bonjour tout le monde" --no-alternatives --no-word-insights --no-suggestions --no-alignments
+```
+
 use the subscriber summarizer:
 
 ```bash
@@ -247,7 +268,9 @@ kagi enrich news "browser privacy"
 
 ## what it looks like
 
-if you want a quick feel for the cli before installing it, this is the kind of output you get from ask-page, the subscriber summarizer, assistant, and the public news feed:
+if you want a quick feel for the cli before installing it, this is the kind of output you get from translate, ask-page, the subscriber summarizer, assistant, and the public news feed:
+
+![translate demo](images/demos/translate.gif)
 
 ![summarize demo](images/demos/summarize.gif)
 
@@ -280,6 +303,3 @@ for the fuller install matrix and platform-specific setup, use the [installation
 ## license
 
 [mit license](LICENSE)
-
-### todo
-- add https://translate.kagi.com/
diff --git a/docs/api-coverage.md b/docs/api-coverage.md
index 510c60e..dee184e 100644
--- a/docs/api-coverage.md
+++ b/docs/api-coverage.md
@@ -13,6 +13,7 @@
 - **Kagi News public product endpoints** - implemented via `kagi news ...`
 - **Subscriber web Assistant prompt flow** - implemented on Kagi Assistant's authenticated tagged stream via `kagi assistant ...`
 - **Subscriber web Assistant thread list/open/delete/export flows** - implemented on the authenticated Assistant thread endpoints via `kagi assistant thread ...`
+- **Kagi Translate text mode** - implemented via `kagi translate ...` with runtime bootstrap from `KAGI_SESSION_TOKEN`
 
 ## Source of truth
 
@@ -29,10 +30,6 @@ This CLI also implements non-public or product-only seams:
 - subscriber web Assistant thread management via Kagi session-token auth
 - Kagi News product endpoints
 
-## TODO / deferred
-
-- **Kagi Translate** - removed from the public CLI surface until there is a live-verified Session Link compatible implementation
-
 ## Notes
 
 - Lens support and runtime search filters are not documented on the official Search API. In this CLI they work through Kagi's live HTML/session flow using the `l`, `r`, `dr`, `from_date`, `to_date`, `order`, `verbatim`, and `personalized` query parameters.
@@ -41,7 +38,7 @@ This CLI also implements non-public or product-only seams:
 - Base-search fallback to session-token search happens on the user-facing `search` command only. `auth check` validates the selected primary credential without fallback.
 - The paid public Summarizer, FastGPT, and Enrichment APIs require `KAGI_API_TOKEN` and sufficient API credit.
 - The subscriber web Summarizer requires `KAGI_SESSION_TOKEN` and uses the authenticated `GET /mother/summary_labs?...` stream path instead of the public `/api/v0/summarize` endpoint.
-- Live verification on March 16, 2026 showed that `https://translate.kagi.com/api/auth` returns `null` even when the same `KAGI_SESSION_TOKEN` works on `kagi.com`.
-- Because the repo is marketed around Session Link auth, `translate` was removed from the CLI surface until that mismatch is solved.
+- Live verification on March 18, 2026 showed that direct HTTP bootstrap can mint `translate_session` from the same `KAGI_SESSION_TOKEN` by reading the `Set-Cookie` header from `https://translate.kagi.com/`.
+- After bootstrap, the CLI uses normal Rust HTTP requests for `/api/detect`, `/api/translate`, `/api/alternative-translations`, `/api/text-alignments`, `/api/translation-suggestions`, and `/api/word-insights`.
 - Assistant requires `KAGI_SESSION_TOKEN` and currently targets `/assistant/prompt`, `/assistant/thread_list`, `/assistant/thread_open`, `/assistant/thread_delete`, and `/assistant/<thread_id>/download`.
 - News uses `https://news.kagi.com/api/...` JSON endpoints and does not require auth.
diff --git a/docs/commands/translate.mdx b/docs/commands/translate.mdx
new file mode 100644
index 0000000..078c7f4
--- /dev/null
+++ b/docs/commands/translate.mdx
@@ -0,0 +1,260 @@
+---
+title: "translate"
+description: "Complete reference for *kagi* translate command - translate text through Kagi Translate with session-token auth."
+---
+
+# `kagi translate`
+
+Translate text through Kagi Translate and return one JSON envelope with the core translation plus the auxiliary text-mode sections.
+
+![Translate demo](/images/demos/translate.gif)
+
+## Synopsis
+
+```bash
+kagi translate [OPTIONS] <TEXT>
+```
+
+## Description
+
+`kagi translate` uses your existing `KAGI_SESSION_TOKEN`, bootstraps a `translate_session` at runtime, then calls the live `translate.kagi.com` endpoints over HTTP.
+
+By default the command fetches:
+
+- language detection
+- translated text
+- alternative translations
+- text alignments
+- translation suggestions
+- word insights
+
+If an auxiliary section fails, the core translation still succeeds and the failure is recorded in `warnings`.
+
+Plain `kagi translate "..."` means `--from auto --to en`. The CLI detects the source language first, then translates to English unless you pass `--to`.
+
+## Authentication
+
+**Required:** `KAGI_SESSION_TOKEN`
+
+The command follows the same Session Link auth story as other subscriber features. Save the full Session Link URL with:
+
+```bash
+kagi auth set --session-token 'https://kagi.com/search?token=...'
+```
+
+## Bootstrap
+
+The CLI uses your existing `KAGI_SESSION_TOKEN` to fetch `https://translate.kagi.com/`, reads the returned `translate_session` cookie from `Set-Cookie`, then uses normal Rust HTTP requests for the rest of the flow.
+
+## Arguments
+
+### `<TEXT>` (Required)
+
+The text to translate.
+
+```bash
+kagi translate "Bonjour tout le monde"
+```
+
+## Core Options
+
+### `--from <LANG>`
+
+Source language code. Default: `auto`.
+
+### `--to <LANG>`
+
+Target language code. Default: `en`. `auto` is not accepted for the target language.
+
+### `--quality <QUALITY>`
+
+Quality preference passed through to Kagi Translate.
+
+### `--model <MODEL>`
+
+Model override passed through to Kagi Translate.
+
+## Context and Style Options
+
+### `--prediction <TEXT>`
+
+Bias translation toward a predicted completion.
+
+### `--predicted-language <LANG>`
+
+Predicted source language code.
+
+### `--formality <LEVEL>`
+
+Formality hint.
+
+### `--speaker-gender <GENDER>`
+
+Speaker gender hint.
+
+### `--addressee-gender <GENDER>`
+
+Addressee gender hint.
+
+### `--language-complexity <LEVEL>`
+
+Language complexity hint.
+
+### `--translation-style <STYLE>`
+
+Translation style hint.
+
+### `--context <TEXT>`
+
+Extra translation context.
+
+### `--dictionary-language <LANG>`
+
+Dictionary language override.
+
+### `--time-format <FORMAT>`
+
+Time formatting style.
+
+### `--use-definition-context <true|false>`
+
+Toggle definition-aware translation behavior.
+
+### `--enable-language-features <true|false>`
+
+Toggle language-feature enrichment.
+
+### `--preserve-formatting <true|false>`
+
+Preserve formatting when possible.
+
+### `--context-memory-json <JSON>`
+
+Raw JSON array passed through as `context_memory`.
+
+```bash
+kagi translate "Bonjour" \
+  --context-memory-json '[{"kind":"glossary","value":"Use Hello, never Hi"}]'
+```
+
+## Auxiliary Section Controls
+
+### `--no-alternatives`
+
+Skip the alternative translations call.
+
+### `--no-word-insights`
+
+Skip the word insights call.
+
+### `--no-suggestions`
+
+Skip the translation suggestions call.
+
+### `--no-alignments`
+
+Skip the text alignments call.
+
+## Output Format
+
+```json
+{
+  "bootstrap": {
+    "method": "reqwest(set-cookie bootstrap)",
+    "authenticated": true
+  },
+  "detected_language": {
+    "iso": "fr",
+    "label": "French"
+  },
+  "translation": {
+    "translation": "Hello everyone",
+    "source_language": "fr",
+    "target_language": "en"
+  },
+  "alternatives": {
+    "elements": []
+  },
+  "text_alignments": {
+    "alignments": []
+  },
+  "translation_suggestions": {
+    "suggestions": []
+  },
+  "word_insights": {
+    "insights": []
+  },
+  "warnings": []
+}
+```
+
+## Examples
+
+### Basic Translation to English
+
+```bash
+kagi translate "Bonjour tout le monde"
+```
+
+### Translate to Japanese
+
+```bash
+kagi translate "Hello everyone" --to ja
+```
+
+### Provide Style and Context
+
+```bash
+kagi translate "Can you review this?" \
+  --to fr \
+  --formality more \
+  --translation-style natural \
+  --context "Professional email to a client"
+```
+
+### Fastest Core Output Only
+
+```bash
+kagi translate "Bonjour tout le monde" \
+  --no-alternatives \
+  --no-word-insights \
+  --no-suggestions \
+  --no-alignments
+```
+
+### Extract Just the Translated Text
+
+```bash
+kagi translate "Bonjour tout le monde" | jq -r '.translation.translation'
+```
+
+## Exit Codes
+
+| Code | Meaning |
+|------|---------|
+| 0 | Success |
+| 1 | Error - see stderr |
+
+## Troubleshooting
+
+### Bootstrap failure
+
+If translate bootstrap fails before detection or translation starts, the session token is likely invalid for the current account state or Kagi changed the cookie bootstrap behavior.
+
+### Invalid session token
+
+Refresh your Session Link and save it again:
+
+```bash
+kagi auth set --session-token 'https://kagi.com/search?token=...'
+```
+
+### Auxiliary section warnings
+
+If `warnings` is non-empty, the translation succeeded but one or more optional follow-on calls were rejected or unavailable.
+
+## See Also
+
+- [Authentication Guide](/guides/authentication)
+- [Auth Matrix](/reference/auth-matrix)
+- [Coverage](/reference/coverage)
diff --git a/docs/demo-assets/translate.gif b/docs/demo-assets/translate.gif
new file mode 100644
index 0000000..648d271
Binary files /dev/null and b/docs/demo-assets/translate.gif differ
diff --git a/docs/demos.md b/docs/demos.md
index a3c9d44..bb574ed 100644
--- a/docs/demos.md
+++ b/docs/demos.md
@@ -11,6 +11,7 @@ The demo scripts build the local debug binary, expose it as `kagi` through `/tmp
 - `docs/demo-assets/news.gif`
 - `docs/demo-assets/ask-page.gif`
 - `docs/demo-assets/assistant.gif`
+- `docs/demo-assets/translate.gif`
 
 ## Regenerate
 
@@ -23,10 +24,12 @@ The current demo commands are:
 - `kagi news --category tech --limit 1 | jq -M ...`
 - `kagi ask-page https://rust-lang.org/ "What is this page about in one sentence?" | jq -M ...`
 - `kagi assistant "plan a private obsidian workflow for cafe work. give me 3 setup tips and a short checklist." | jq -M ...`
+- `kagi translate "Bonjour tout le monde" --to ja | jq -M ...`
 - `RESPONSE=$(kagi assistant --model gpt-5-mini "..."); THREAD_ID=...; kagi assistant --thread-id "$THREAD_ID" "..."; kagi assistant thread export "$THREAD_ID"`
+ - `kagi translate "Bonjour tout le monde" --to ja | jq -M ...`
 
 ```bash
-chmod +x scripts/demo-search.sh scripts/demo-summarize.sh scripts/demo-news.sh scripts/demo-ask-page.sh scripts/demo-assistant.sh
+chmod +x scripts/demo-search.sh scripts/demo-summarize.sh scripts/demo-news.sh scripts/demo-ask-page.sh scripts/demo-assistant.sh scripts/demo-translate.sh
 
 mkdir -p docs/demo-assets /tmp/kagi-demos
 
@@ -38,12 +41,14 @@ KAGI_SESSION_TOKEN='...' asciinema rec -c ./scripts/demo-summarize.sh -q -i 0.2
 asciinema rec -c ./scripts/demo-news.sh -q -i 0.2 --cols 92 --rows 22 /tmp/kagi-demos/news.cast
 KAGI_SESSION_TOKEN='...' asciinema rec -c ./scripts/demo-ask-page.sh -q -i 0.2 --cols 92 --rows 22 /tmp/kagi-demos/ask-page.cast
 KAGI_SESSION_TOKEN='...' asciinema rec -c ./scripts/demo-assistant.sh -q -i 0.2 --cols 92 --rows 22 /tmp/kagi-demos/assistant.cast
+KAGI_SESSION_TOKEN='...' asciinema rec -c ./scripts/demo-translate.sh -q -i 0.2 --cols 92 --rows 22 /tmp/kagi-demos/translate.cast
 
 agg --theme asciinema --font-size 14 --idle-time-limit 2 --last-frame-duration 4 /tmp/kagi-demos/search.cast docs/demo-assets/search.gif
 agg --theme asciinema --font-size 14 --idle-time-limit 2 --last-frame-duration 4 /tmp/kagi-demos/summarize.cast docs/demo-assets/summarize.gif
 agg --theme asciinema --font-size 14 --idle-time-limit 2 --last-frame-duration 4 /tmp/kagi-demos/news.cast docs/demo-assets/news.gif
 agg --theme asciinema --font-size 14 --idle-time-limit 2 --last-frame-duration 4 /tmp/kagi-demos/ask-page.cast docs/demo-assets/ask-page.gif
 agg --theme asciinema --font-size 14 --idle-time-limit 2 --last-frame-duration 4 /tmp/kagi-demos/assistant.cast docs/demo-assets/assistant.gif
+agg --theme asciinema --font-size 14 --idle-time-limit 2 --last-frame-duration 4 /tmp/kagi-demos/translate.cast docs/demo-assets/translate.gif
 ```
 
 If `agg --version` does not print `asciinema gif generator`, your `PATH` is resolving a different package. Use the official binary explicitly, for example `~/.cargo/bin/agg`.
diff --git a/docs/docs.json b/docs/docs.json
index be8d5a4..547e0eb 100644
--- a/docs/docs.json
+++ b/docs/docs.json
@@ -86,6 +86,7 @@
             "pages": [
               "commands/ask-page",
               "commands/assistant",
+              "commands/translate",
               "commands/fastgpt",
               "commands/enrich"
             ]
diff --git a/docs/guides/quickstart.mdx b/docs/guides/quickstart.mdx
index bdb616e..bdc5c1b 100644
--- a/docs/guides/quickstart.mdx
+++ b/docs/guides/quickstart.mdx
@@ -177,6 +177,9 @@ kagi search --region us --time month --order recency "rust release notes"
 # Test Assistant
 kagi assistant "What are the key features of Rust?"
 
+# Test Translate
+kagi translate "Bonjour tout le monde" --to ja
+
 # Ask Assistant about a page
 kagi ask-page https://rust-lang.org/ "What is this page about?"
 
@@ -195,6 +198,10 @@ kagi summarize --subscriber --url https://www.rust-lang.org --summary-type keypo
 
 ![Ask Page command demo](/images/demos/ask-page.gif)
 
+**Translate Demo:**
+
+![Translate command demo](/images/demos/translate.gif)
+
 **Subscriber Summarize Demo:**
 
 ![Summarize command demo](/images/demos/summarize.gif)
diff --git a/docs/index.mdx b/docs/index.mdx
index b5ff3a3..25b274f 100644
--- a/docs/index.mdx
+++ b/docs/index.mdx
@@ -52,6 +52,8 @@ Unlock the full potential of your Kagi subscription:
 - **Assistant Integration**: Prompt Kagi Assistant programmatically, continue conversations, and manage threads across sessions.
 - **Ask Page**: Start a page-focused Assistant thread directly from one URL and one question.
 
+- **Translate Integration**: Run Kagi Translate text mode from the terminal with one JSON response envelope.
+
 - **Subscriber Features**: Access subscriber-only capabilities like the web-based Summarizer with full control over output length and style.
 
 ## Feature Overview
@@ -70,13 +72,14 @@ The `kagi search` command provides multiple pathways depending on your authentic
 
 Two credential types serve different purposes:
 
-- **KAGI_SESSION_TOKEN**: Unlocks subscriber features including lens search, Assistant, and subscriber Summarizer. Obtained from your Kagi Session Link URL.
+- **KAGI_SESSION_TOKEN**: Unlocks subscriber features including lens search, Assistant, subscriber Summarizer, and Translate text mode. Obtained from your Kagi Session Link URL.
 
 - **KAGI_API_TOKEN**: Enables paid public API commands including FastGPT, public Summarizer, and enrichment APIs. Requires API credit.
 
 ### Content Processing
 
 - **Summarization**: Both paid public API and subscriber web paths with multiple engines, styles, and output lengths
+- **Translation**: Text-mode Kagi Translate with detection, alternatives, alignments, suggestions, and word insights
 - **FastGPT**: Quick answers powered by Kagi's FastGPT API
 - **Enrichment**: Query specialized web and news indexes
 - **Assistant**: Full conversation support with thread continuation and thread management
@@ -108,8 +111,9 @@ flowchart TB
         web1["search --lens"]
         web2["assistant"]
         web3["summarize --subscriber"]
-        web4["search (session)"]
-        web5["ask-page"]
+        web4["translate"]
+        web5["search (session)"]
+        web6["ask-page"]
     end
     
     subgraph PublicFeeds["Public Feeds (No Auth)"]
@@ -161,7 +165,6 @@ Choose your path based on your current needs:
 
 ### Runtime Requirements
 
-- No runtime dependencies (self-contained binary)
 - Network connectivity to kagi.com
 - Shell environment (Bash, Zsh, Fish, PowerShell, or CMD)
 
diff --git a/docs/project/demos.mdx b/docs/project/demos.mdx
index 081dada..41c8c70 100644
--- a/docs/project/demos.mdx
+++ b/docs/project/demos.mdx
@@ -12,6 +12,7 @@ The docs site ships with recorded terminal GIFs from the repo:
 - news
 - ask-page
 - assistant
+- translate
 
 ## Preview
 
@@ -35,6 +36,10 @@ The docs site ships with recorded terminal GIFs from the repo:
 
 ![Ask Page demo](/images/demos/ask-page.gif)
 
+### Translate
+
+![Translate demo](/images/demos/translate.gif)
+
 ## Regenerate
 
 Subscriber demos require `KAGI_SESSION_TOKEN`.
@@ -49,9 +54,10 @@ The current demo commands are:
 - `kagi ask-page https://rust-lang.org/ "What is this page about in one sentence?" | jq -M ...`
 - `kagi assistant "plan a private obsidian workflow for cafe work. give me 3 setup tips and a short checklist." | jq -M ...`
 - `RESPONSE=$(kagi assistant --model gpt-5-mini "..."); THREAD_ID=...; kagi assistant --thread-id "$THREAD_ID" "..."; kagi assistant thread export "$THREAD_ID"`
+- `kagi translate "Bonjour tout le monde" --to ja | jq -M ...`
 
 ```bash
-chmod +x scripts/demo-search.sh scripts/demo-summarize.sh scripts/demo-news.sh scripts/demo-ask-page.sh scripts/demo-assistant.sh
+chmod +x scripts/demo-search.sh scripts/demo-summarize.sh scripts/demo-news.sh scripts/demo-ask-page.sh scripts/demo-assistant.sh scripts/demo-translate.sh
 
 mkdir -p docs/demo-assets /tmp/kagi-demos
 
@@ -61,6 +67,7 @@ KAGI_SESSION_TOKEN='...' asciinema rec -c ./scripts/demo-summarize.sh -q -i 0.2
 asciinema rec -c ./scripts/demo-news.sh -q -i 0.2 --cols 92 --rows 22 /tmp/kagi-demos/news.cast
 KAGI_SESSION_TOKEN='...' asciinema rec -c ./scripts/demo-ask-page.sh -q -i 0.2 --cols 92 --rows 22 /tmp/kagi-demos/ask-page.cast
 KAGI_SESSION_TOKEN='...' asciinema rec -c ./scripts/demo-assistant.sh -q -i 0.2 --cols 92 --rows 22 /tmp/kagi-demos/assistant.cast
+KAGI_SESSION_TOKEN='...' asciinema rec -c ./scripts/demo-translate.sh -q -i 0.2 --cols 92 --rows 22 /tmp/kagi-demos/translate.cast
 ```
 
 ## Rendering
@@ -73,4 +80,5 @@ agg --theme asciinema --font-size 14 --idle-time-limit 2 --last-frame-duration 4
 agg --theme asciinema --font-size 14 --idle-time-limit 2 --last-frame-duration 4 /tmp/kagi-demos/news.cast docs/demo-assets/news.gif
 agg --theme asciinema --font-size 14 --idle-time-limit 2 --last-frame-duration 4 /tmp/kagi-demos/ask-page.cast docs/demo-assets/ask-page.gif
 agg --theme asciinema --font-size 14 --idle-time-limit 2 --last-frame-duration 4 /tmp/kagi-demos/assistant.cast docs/demo-assets/assistant.gif
+agg --theme asciinema --font-size 14 --idle-time-limit 2 --last-frame-duration 4 /tmp/kagi-demos/translate.cast docs/demo-assets/translate.gif
 ```
diff --git a/docs/reference/auth-matrix.mdx b/docs/reference/auth-matrix.mdx
index 225ee97..3888d62 100644
--- a/docs/reference/auth-matrix.mdx
+++ b/docs/reference/auth-matrix.mdx
@@ -22,6 +22,7 @@ This reference provides a complete mapping of which commands require which authe
 | `news` | None | None | Public endpoint |
 | `ask-page` | `KAGI_SESSION_TOKEN` | None | Subscriber feature |
 | `assistant` | `KAGI_SESSION_TOKEN` | None | Subscriber feature |
+| `translate` | `KAGI_SESSION_TOKEN` | None | Text mode only; bootstraps `translate_session` over HTTP |
 | `fastgpt` | `KAGI_API_TOKEN` | None | Paid public API |
 | `enrich web` | `KAGI_API_TOKEN` | None | Paid public API |
 | `enrich news` | `KAGI_API_TOKEN` | None | Paid public API |
@@ -128,6 +129,7 @@ flowchart TD
 |---------|-------|---------|
 | `ask-page` | `KAGI_SESSION_TOKEN` | Ask Assistant about one page URL |
 | `assistant` | `KAGI_SESSION_TOKEN` | Conversational AI with threads |
+| `translate` | `KAGI_SESSION_TOKEN` | Kagi Translate text mode |
 | `fastgpt` | `KAGI_API_TOKEN` | Quick factual answers |
 
 ### Data Commands
@@ -158,6 +160,7 @@ Requires `KAGI_SESSION_TOKEN`:
 - ✅ Filtered search (`--region`, `--time`, `--from-date`, `--to-date`, `--order`, `--verbatim`, personalization flags)
 - ✅ Kagi Assistant prompt and thread commands (`assistant`)
 - ✅ Ask Page (`ask-page`)
+- ✅ Kagi Translate (`translate`)
 - ✅ Subscriber Summarizer (`summarize --subscriber`)
 - ✅ Base search (fallback)
 
@@ -237,6 +240,7 @@ kagi auth set --session-token 'https://kagi.com/search?token=...'
 - ✅ `kagi ask-page https://example.com "question"`
 - ✅ `kagi ask-page https://example.com "question"`
 - ✅ `kagi assistant "prompt"`
+- ✅ `kagi translate "Bonjour tout le monde"`
 - ✅ `kagi summarize --subscriber --url ...`
 - ✅ `kagi news`
 - ✅ `kagi smallweb`
@@ -347,6 +351,7 @@ kagi assistant "prompt"
 | Use my lens | Session | `kagi search --lens` |
 | Quick answers | API | `kagi fastgpt` |
 | AI conversation | Session | `kagi assistant` |
+| Translate text | Session | `kagi translate` |
 | Summarize (free API) | API | `kagi summarize --url` |
 | Summarize (subscription) | Session | `kagi summarize --subscriber` |
 | Read news | None | `kagi news` |
diff --git a/docs/reference/coverage.mdx b/docs/reference/coverage.mdx
index 73593e2..58accb0 100644
--- a/docs/reference/coverage.mdx
+++ b/docs/reference/coverage.mdx
@@ -33,6 +33,7 @@ These features use the subscriber web product (Session Token):
 | Web Summarizer | `kagi summarize --subscriber` | ✅ Implemented |
 | Assistant prompt + thread management | `kagi assistant` | ✅ Implemented |
 | Ask Questions About a Page | `kagi ask-page` | ✅ Implemented |
+| Translate (text mode) | `kagi translate` | ✅ Implemented |
 
 ### Public Product Endpoints
 
@@ -60,6 +61,7 @@ These require no authentication:
 | `news` | News feed | None | ✅ |
 | `assistant` | AI assistant with thread management | Session | ✅ |
 | `ask-page` | Page-focused Assistant question | Session | ✅ |
+| `translate` | Kagi Translate text mode | Session | ✅ |
 | `fastgpt` | Fast answers | API | ✅ |
 | `enrich web` | Web enrichment | API | ✅ |
 | `enrich news` | News enrichment | API | ✅ |
@@ -93,6 +95,13 @@ These require no authentication:
 | `--target-language` | summarize | ✅ |
 | `<URL> <QUESTION>` | ask-page | ✅ |
 | `--thread-id` | assistant | ✅ |
+| `--from`, `--to` | translate | ✅ |
+| `--no-alternatives`, `--no-word-insights`, `--no-suggestions`, `--no-alignments` | translate | ✅ |
+| `--model` | assistant | ✅ |
+| `--lens` | assistant | ✅ |
+| `--web-access` / `--no-web-access` | assistant | ✅ |
+| `--personalized` / `--no-personalized` | assistant | ✅ |
+| `thread list/get/delete/export` | assistant | ✅ |
 | `--model` | assistant | ✅ |
 | `--lens` | assistant | ✅ |
 | `--web-access` / `--no-web-access` | assistant | ✅ |
@@ -105,15 +114,7 @@ These require no authentication:
 
 These features were evaluated and left out of the public CLI surface:
 
-#### Translate
-
-**Status:** ❌ Not implemented
-
-**Reason:** The current Session Link implementation is not sufficient for `translate.kagi.com` as deployed. The endpoint requires additional authentication mechanisms that are incompatible with the Session Link token model.
-
-**Decision:** Rather than ship a fragile compatibility layer that might break, the feature is excluded until there is a viable authentication path.
-
-**Alternative:** Use the web interface at [translate.kagi.com](https://translate.kagi.com)
+There is no public CLI support today for document, website, image, proofread, dictionary, or voice modes from Kagi Translate. The implemented scope is text mode only.
 
 ## API Surface Philosophy
 
@@ -137,7 +138,7 @@ These features were evaluated and left out of the public CLI surface:
 
 | Type | Support | Commands |
 |------|---------|----------|
-| Session Token | ✅ | search, filtered search, ask-page, summarize --subscriber, assistant |
+| Session Token | ✅ | search, filtered search, ask-page, summarize --subscriber, assistant, translate |
 | API Token | ✅ | search, summarize, fastgpt, enrich |
 
 ### Authentication Patterns
@@ -164,6 +165,7 @@ All commands output JSON:
 | summarize | Stable |
 | ask-page | Stable |
 | assistant | Stable |
+| translate | Stable |
 | fastgpt | Stable |
 | enrich | Stable |
 
@@ -212,7 +214,7 @@ All commands output JSON:
 | Assistant | ✅ (prompt + threads) | ✅ (full) |
 | Ask Questions about Page | ✅ | ✅ |
 | Summarizer | ✅ | ✅ |
-| Translate | ❌ | ✅ |
+| Translate | ✅ (text mode) | ✅ |
 | Settings | ❌ | ✅ |
 | Billing | ❌ | ✅ |
 
diff --git a/docs/reference/error-reference.mdx b/docs/reference/error-reference.mdx
index 2c05831..3af2b8f 100644
--- a/docs/reference/error-reference.mdx
+++ b/docs/reference/error-reference.mdx
@@ -155,6 +155,27 @@ rm ./.kagi.toml
 kagi auth set --session-token 'YOUR_TOKEN'
 ```
 
+### "translate bootstrap did not mint a translate_session cookie"
+
+**Meaning:** The translate site accepted the request but did not issue the session cookie the CLI needs for follow-on API calls.
+
+**Likely causes:**
+- `KAGI_SESSION_TOKEN` is invalid or expired
+- the current Kagi account state no longer authorizes Translate
+- Kagi changed the bootstrap cookie behavior
+
+**Solution:**
+```bash
+# refresh and save the current Session Link
+kagi auth set --session-token 'https://kagi.com/search?token=...'
+
+# verify the token still works for subscriber features
+kagi auth check
+
+# retry translate
+kagi translate "Bonjour tout le monde"
+```
+
 ## Command Errors
 
 ### "search filters require KAGI_SESSION_TOKEN"
@@ -242,6 +263,21 @@ Error: Config: --cache is only supported for the paid public summarizer API
 kagi summarize --url https://example.com --cache false
 ```
 
+### "translate --to cannot be 'auto'; pass an explicit target language code"
+
+**Message:**
+```text
+configuration error: translate --to cannot be 'auto'; pass an explicit target language code
+```
+
+**Meaning:** Translate can auto-detect the source language, but the target language must always be explicit.
+
+**Solution:**
+```bash
+kagi translate "Bonjour tout le monde" --to en
+kagi translate "Bonjour tout le monde" --to ja
+```
+
 ### "--url or --text required"
 
 **Meaning:** Summarize command needs content to summarize.
diff --git a/docs/reference/output-contract.mdx b/docs/reference/output-contract.mdx
index d44e003..c0c5c6e 100644
--- a/docs/reference/output-contract.mdx
+++ b/docs/reference/output-contract.mdx
@@ -137,6 +137,39 @@ Subscriber mode:
 }
 ```
 
+### `kagi translate`
+
+```json
+{
+  "bootstrap": {
+    "method": "reqwest(set-cookie bootstrap)",
+    "authenticated": true
+  },
+  "detected_language": {
+    "iso": "fr",
+    "label": "French"
+  },
+  "translation": {
+    "translation": "Hello everyone",
+    "source_language": "fr",
+    "target_language": "en"
+  },
+  "alternatives": {
+    "elements": []
+  },
+  "text_alignments": {
+    "alignments": []
+  },
+  "translation_suggestions": {
+    "suggestions": []
+  },
+  "word_insights": {
+    "insights": []
+  },
+  "warnings": []
+}
+```
+
 ### `kagi ask-page`
 
 ```json
@@ -248,6 +281,9 @@ kagi fastgpt "What is Rust?" | jq -r '.data.output'
 # Assistant markdown reply
 kagi assistant "Hello" | jq -r '.message.markdown'
 
+# Translate text
+kagi translate "Bonjour tout le monde" | jq -r '.translation.translation'
+
 # Ask-page markdown reply
 kagi ask-page https://rust-lang.org/ "What is this page about?" | jq -r '.message.markdown'
 
diff --git a/images/demos/translate.gif b/images/demos/translate.gif
new file mode 100644
index 0000000..648d271
Binary files /dev/null and b/images/demos/translate.gif differ
diff --git a/project/demos.mdx b/project/demos.mdx
index b6ccda0..1e75710 100644
--- a/project/demos.mdx
+++ b/project/demos.mdx
@@ -12,6 +12,7 @@ The docs site ships with recorded terminal GIFs from the repo:
 - news
 - ask-page
 - assistant
+- translate
 
 ## Preview
 
@@ -35,6 +36,10 @@ The docs site ships with recorded terminal GIFs from the repo:
 
 ![Ask Page demo](/images/demos/ask-page.gif)
 
+### Translate
+
+![Translate demo](/images/demos/translate.gif)
+
 ## Regenerate
 
 Subscriber demos require `KAGI_SESSION_TOKEN`.
@@ -49,9 +54,10 @@ The current demo commands are:
 - `kagi ask-page https://rust-lang.org/ "What is this page about in one sentence?" | jq -M ...`
 - `kagi assistant "plan a private obsidian workflow for cafe work. give me 3 setup tips and a short checklist." | jq -M ...`
 - `RESPONSE=$(kagi assistant --model gpt-5-mini "..."); THREAD_ID=...; kagi assistant --thread-id "$THREAD_ID" "..."; kagi assistant thread export "$THREAD_ID"`
+- `kagi translate "Bonjour tout le monde" --to ja | jq -M ...`
 
 ```bash
-chmod +x scripts/demo-search.sh scripts/demo-summarize.sh scripts/demo-news.sh scripts/demo-ask-page.sh scripts/demo-assistant.sh
+chmod +x scripts/demo-search.sh scripts/demo-summarize.sh scripts/demo-news.sh scripts/demo-ask-page.sh scripts/demo-assistant.sh scripts/demo-translate.sh
 
 mkdir -p docs/demo-assets /tmp/kagi-demos
 
@@ -61,6 +67,7 @@ KAGI_SESSION_TOKEN='...' asciinema rec -c ./scripts/demo-summarize.sh -q -i 0.2
 asciinema rec -c ./scripts/demo-news.sh -q -i 0.2 --cols 92 --rows 22 /tmp/kagi-demos/news.cast
 KAGI_SESSION_TOKEN='...' asciinema rec -c ./scripts/demo-ask-page.sh -q -i 0.2 --cols 92 --rows 22 /tmp/kagi-demos/ask-page.cast
 KAGI_SESSION_TOKEN='...' asciinema rec -c ./scripts/demo-assistant.sh -q -i 0.2 --cols 92 --rows 22 /tmp/kagi-demos/assistant.cast
+KAGI_SESSION_TOKEN='...' asciinema rec -c ./scripts/demo-translate.sh -q -i 0.2 --cols 92 --rows 22 /tmp/kagi-demos/translate.cast
 ```
 
 ## Rendering
@@ -73,4 +80,5 @@ agg --theme asciinema --font-size 14 --idle-time-limit 2 --last-frame-duration 2
 agg --theme asciinema --font-size 14 --idle-time-limit 2 --last-frame-duration 2 /tmp/kagi-demos/news.cast docs/demo-assets/news.gif
 agg --theme asciinema --font-size 14 --idle-time-limit 2 --last-frame-duration 2 /tmp/kagi-demos/ask-page.cast docs/demo-assets/ask-page.gif
 agg --theme asciinema --font-size 14 --idle-time-limit 2 --last-frame-duration 2 /tmp/kagi-demos/assistant.cast docs/demo-assets/assistant.gif
+agg --theme asciinema --font-size 14 --idle-time-limit 2 --last-frame-duration 2 /tmp/kagi-demos/translate.cast docs/demo-assets/translate.gif
 ```
diff --git a/scripts/demo-assistant.sh b/scripts/demo-assistant.sh
index 9c87c55..a2dcc17 100755
--- a/scripts/demo-assistant.sh
+++ b/scripts/demo-assistant.sh
@@ -1,4 +1,6 @@
 #!/usr/bin/env bash
+#!/usr/bin/env bash
+
 set -euo pipefail
 
 cd "$(dirname "$0")/.."
diff --git a/scripts/demo-news.sh b/scripts/demo-news.sh
index 17c3ea5..c1194e6 100755
--- a/scripts/demo-news.sh
+++ b/scripts/demo-news.sh
@@ -1,4 +1,6 @@
 #!/usr/bin/env bash
+#!/usr/bin/env bash
+
 set -euo pipefail
 
 cd "$(dirname "$0")/.."
diff --git a/scripts/demo-search.sh b/scripts/demo-search.sh
index 4b36e17..c7c4db2 100755
--- a/scripts/demo-search.sh
+++ b/scripts/demo-search.sh
@@ -1,4 +1,6 @@
 #!/usr/bin/env bash
+#!/usr/bin/env bash
+
 set -euo pipefail
 
 cd "$(dirname "$0")/.."
diff --git a/scripts/demo-summarize.sh b/scripts/demo-summarize.sh
index d3fe026..d422589 100755
--- a/scripts/demo-summarize.sh
+++ b/scripts/demo-summarize.sh
@@ -1,4 +1,6 @@
 #!/usr/bin/env bash
+#!/usr/bin/env bash
+
 set -euo pipefail
 
 cd "$(dirname "$0")/.."
diff --git a/scripts/demo-translate.sh b/scripts/demo-translate.sh
new file mode 100755
index 0000000..0c9b578
--- /dev/null
+++ b/scripts/demo-translate.sh
@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+cd "$(dirname "$0")/.."
+
+: "${KAGI_SESSION_TOKEN:?set KAGI_SESSION_TOKEN before running this demo}"
+
+cargo build --quiet
+mkdir -p /tmp/kagi-demo-bin
+ln -sf "$PWD/target/debug/kagi" /tmp/kagi-demo-bin/kagi
+export PATH="/tmp/kagi-demo-bin:$PATH"
+
+printf '\033c'
+sleep 1.2
+printf '$ kagi translate "Bonjour tout le monde" --to ja | jq -M ...\n'
+sleep 0.4
+kagi translate "Bonjour tout le monde" --to ja \
+  | jq -M '{
+      detected_language: .detected_language.label,
+      translation: .translation.translation,
+      alignments: (.text_alignments.alignments | length),
+      alternatives: (.alternatives.elements | map(.translation)[0:3]),
+      suggestion_labels: (.translation_suggestions.suggestions | map(.label)[0:3]),
+      word_insight_terms: (.word_insights.insights | map(.original_text)[0:3])
+    }'
+sleep 2
diff --git a/src/api.rs b/src/api.rs
index 9d28464..41204a8 100644
--- a/src/api.rs
+++ b/src/api.rs
@@ -1,4 +1,5 @@
 use std::collections::HashMap;
+use std::future::Future;
 
 use reqwest::{Client, StatusCode, Url, header};
 use scraper::Html;
@@ -6,23 +7,26 @@ use serde::Deserialize;
 #[cfg(test)]
 use serde::Serialize;
 use serde::de::DeserializeOwned;
-use serde_json::Value;
 use serde_json::json;
+use serde_json::{Map, Value};
 
 use crate::error::KagiError;
 use crate::parser::parse_assistant_thread_list;
 #[cfg(test)]
 use crate::types::ApiMeta;
 use crate::types::{
-    AskPageRequest, AskPageResponse, AskPageSource, AssistantMessage, AssistantMeta,
-    AssistantPromptRequest, AssistantPromptResponse, AssistantThread,
-    AssistantThreadDeleteResponse, AssistantThreadExportResponse, AssistantThreadListResponse,
-    AssistantThreadOpenResponse, AssistantThreadPagination, EnrichResponse, FastGptRequest,
-    FastGptResponse, NewsBatchCategories, NewsBatchCategory, NewsCategoriesResponse,
-    NewsCategoryMetadata, NewsCategoryMetadataList, NewsChaos, NewsChaosResponse, NewsLatestBatch,
-    NewsResolvedCategory, NewsStoriesPayload, NewsStoriesResponse, SmallWebFeed,
-    SubscriberSummarization, SubscriberSummarizeMeta, SubscriberSummarizeRequest,
-    SubscriberSummarizeResponse, SummarizeRequest, SummarizeResponse,
+    AlternativeTranslationsResponse, AskPageRequest, AskPageResponse, AskPageSource,
+    AssistantMessage, AssistantMeta, AssistantPromptRequest, AssistantPromptResponse,
+    AssistantThread, AssistantThreadDeleteResponse, AssistantThreadExportResponse,
+    AssistantThreadListResponse, AssistantThreadOpenResponse, AssistantThreadPagination,
+    EnrichResponse, FastGptRequest, FastGptResponse, NewsBatchCategories, NewsBatchCategory,
+    NewsCategoriesResponse, NewsCategoryMetadata, NewsCategoryMetadataList, NewsChaos,
+    NewsChaosResponse, NewsLatestBatch, NewsResolvedCategory, NewsStoriesPayload,
+    NewsStoriesResponse, SmallWebFeed, SubscriberSummarization, SubscriberSummarizeMeta,
+    SubscriberSummarizeRequest, SubscriberSummarizeResponse, SummarizeRequest, SummarizeResponse,
+    TextAlignmentsResponse, TranslateBootstrapMetadata, TranslateCommandRequest,
+    TranslateDetectedLanguage, TranslateOptionState, TranslateResponse, TranslateTextResponse,
+    TranslateWarning, TranslationSuggestionsResponse, WordInsightsResponse,
 };
 
 const USER_AGENT: &str = "kagi-cli/0.1.0 (+https://github.com/)";
@@ -39,6 +43,14 @@ const KAGI_FASTGPT_URL: &str = "https://kagi.com/api/v0/fastgpt";
 const KAGI_ENRICH_WEB_URL: &str = "https://kagi.com/api/v0/enrich/web";
 const KAGI_ENRICH_NEWS_URL: &str = "https://kagi.com/api/v0/enrich/news";
 const KAGI_SMALLWEB_FEED_URL: &str = "https://kagi.com/api/v1/smallweb/feed/";
+const KAGI_TRANSLATE_DETECT_URL: &str = "https://translate.kagi.com/api/detect";
+const KAGI_TRANSLATE_URL: &str = "https://translate.kagi.com/api/translate";
+const KAGI_TRANSLATE_ALTERNATIVES_URL: &str =
+    "https://translate.kagi.com/api/alternative-translations";
+const KAGI_TRANSLATE_ALIGNMENTS_URL: &str = "https://translate.kagi.com/api/text-alignments";
+const KAGI_TRANSLATE_SUGGESTIONS_URL: &str =
+    "https://translate.kagi.com/api/translation-suggestions";
+const KAGI_TRANSLATE_WORD_INSIGHTS_URL: &str = "https://translate.kagi.com/api/word-insights";
 const ASSISTANT_ZERO_BRANCH_UUID: &str = "00000000-0000-4000-0000-000000000000";
 
 pub async fn execute_summarize(
@@ -466,6 +478,130 @@ pub async fn execute_ask_page(
     })
 }
 
+pub async fn execute_translate(
+    request: &TranslateCommandRequest,
+    session_token: &str,
+) -> Result<TranslateResponse, KagiError> {
+    if session_token.trim().is_empty() {
+        return Err(KagiError::Auth(
+            "missing Kagi session token (expected KAGI_SESSION_TOKEN)".to_string(),
+        ));
+    }
+
+    validate_translate_request(request)?;
+
+    let bootstrap = bootstrap_translate_session(session_token).await?;
+    let client = build_client()?;
+    let cookie_header = build_translate_cookie_header(session_token, &bootstrap.translate_session);
+    let detected_language =
+        execute_translate_detect(&client, &cookie_header, request.text.trim()).await?;
+    let effective_source_language =
+        effective_translate_source_language(&request.from, &detected_language);
+    let translation = execute_translate_text(
+        &client,
+        &cookie_header,
+        request,
+        &bootstrap.translate_session,
+        &effective_source_language,
+    )
+    .await?;
+    let target_language = request.to.clone();
+    let translation = finalize_translate_text_response(
+        translation,
+        &detected_language,
+        &effective_source_language,
+        &target_language,
+    );
+    let translation_options = build_translate_option_state(request);
+    let translated_text = translation.translation.clone();
+    let translate_session = bootstrap.translate_session.clone();
+
+    let (alternatives_result, alignments_result, suggestions_result, insights_result) = tokio::join!(
+        capture_optional_translate_section(
+            "alternatives",
+            request.fetch_alternatives,
+            execute_translate_alternatives(
+                &client,
+                &cookie_header,
+                &translate_session,
+                request,
+                &effective_source_language,
+                &translated_text,
+                translation_options.as_ref(),
+            ),
+        ),
+        capture_optional_translate_section(
+            "text_alignments",
+            request.fetch_alignments,
+            execute_translate_text_alignments(
+                &client,
+                &cookie_header,
+                &translate_session,
+                request.text.trim(),
+                &translated_text,
+            ),
+        ),
+        capture_optional_translate_section(
+            "translation_suggestions",
+            request.fetch_suggestions,
+            execute_translate_suggestions(
+                &client,
+                &cookie_header,
+                &translate_session,
+                TranslateSuggestionContext {
+                    source_text: request.text.trim(),
+                    target_text: &translated_text,
+                    source_language: &effective_source_language,
+                    target_language: &target_language,
+                    translation_options: translation_options.as_ref(),
+                },
+            ),
+        ),
+        capture_optional_translate_section(
+            "word_insights",
+            request.fetch_word_insights,
+            execute_translate_word_insights(
+                &client,
+                &cookie_header,
+                &translate_session,
+                request.text.trim(),
+                &translated_text,
+                &target_language,
+                translation_options.as_ref(),
+            ),
+        ),
+    );
+
+    let (alternatives, alternatives_warning) = alternatives_result;
+    let (text_alignments, alignments_warning) = alignments_result;
+    let (translation_suggestions, suggestions_warning) = suggestions_result;
+    let (word_insights, insights_warning) = insights_result;
+
+    let warnings = vec![
+        alternatives_warning,
+        alignments_warning,
+        suggestions_warning,
+        insights_warning,
+    ]
+    .into_iter()
+    .flatten()
+    .collect();
+
+    Ok(TranslateResponse {
+        bootstrap: TranslateBootstrapMetadata {
+            method: bootstrap.method,
+            authenticated: true,
+        },
+        detected_language,
+        translation,
+        alternatives,
+        text_alignments,
+        translation_suggestions,
+        word_insights,
+        warnings,
+    })
+}
+
 pub async fn execute_fastgpt(
     request: &FastGptRequest,
     token: &str,
@@ -546,6 +682,222 @@ async fn execute_enrich(
     decode_kagi_json(response, surface).await
 }
 
+async fn bootstrap_translate_session(
+    session_token: &str,
+) -> Result<TranslateBootstrapResult, KagiError> {
+    let client = build_client()?;
+    let response = client
+        .get("https://translate.kagi.com/")
+        .header(header::COOKIE, format!("kagi_session={session_token}"))
+        .send()
+        .await
+        .map_err(map_transport_error)?;
+
+    resolve_translate_bootstrap(response.status(), response.headers())
+}
+
+async fn execute_translate_detect(
+    client: &Client,
+    cookie_header: &str,
+    text: &str,
+) -> Result<TranslateDetectedLanguage, KagiError> {
+    let response = client
+        .post(KAGI_TRANSLATE_DETECT_URL)
+        .header(header::COOKIE, cookie_header)
+        .header(header::CONTENT_TYPE, "application/json")
+        .json(&json!({
+            "text": text,
+            "include_alternatives": true,
+        }))
+        .send()
+        .await
+        .map_err(map_transport_error)?;
+
+    let value: Value = decode_translate_json(response, "language detection").await?;
+    parse_translate_detect_value(value)
+}
+
+async fn execute_translate_text(
+    client: &Client,
+    cookie_header: &str,
+    request: &TranslateCommandRequest,
+    translate_session: &str,
+    effective_source_language: &str,
+) -> Result<TranslateTextResponse, KagiError> {
+    let response = client
+        .post(KAGI_TRANSLATE_URL)
+        .header(header::COOKIE, cookie_header)
+        .header(header::CONTENT_TYPE, "application/json")
+        .json(&build_translate_payload(
+            request,
+            translate_session,
+            effective_source_language,
+        ))
+        .send()
+        .await
+        .map_err(map_transport_error)?;
+
+    decode_translate_json(response, "translation").await
+}
+
+async fn execute_translate_alternatives(
+    client: &Client,
+    cookie_header: &str,
+    translate_session: &str,
+    request: &TranslateCommandRequest,
+    effective_source_language: &str,
+    translated_text: &str,
+    translation_options: Option<&TranslateOptionState>,
+) -> Result<AlternativeTranslationsResponse, KagiError> {
+    let mut payload = Map::new();
+    payload.insert(
+        "original_text".to_string(),
+        Value::String(request.text.clone()),
+    );
+    payload.insert(
+        "existing_translation".to_string(),
+        Value::String(translated_text.to_string()),
+    );
+    payload.insert(
+        "source_lang".to_string(),
+        Value::String(effective_source_language.to_string()),
+    );
+    payload.insert("target_lang".to_string(), Value::String(request.to.clone()));
+    payload.insert(
+        "session_token".to_string(),
+        Value::String(translate_session.to_string()),
+    );
+
+    if let Some(quality) = normalize_aux_quality(request.quality.as_deref()) {
+        payload.insert("quality".to_string(), Value::String(quality));
+    }
+
+    if let Some(options) = translation_options {
+        payload.insert(
+            "translation_options".to_string(),
+            serde_json::to_value(options).map_err(|error| {
+                KagiError::Parse(format!(
+                    "failed to serialize translate alternatives options: {error}"
+                ))
+            })?,
+        );
+    }
+
+    let response = client
+        .post(KAGI_TRANSLATE_ALTERNATIVES_URL)
+        .header(header::COOKIE, cookie_header)
+        .header(header::CONTENT_TYPE, "application/json")
+        .json(&Value::Object(payload))
+        .send()
+        .await
+        .map_err(map_transport_error)?;
+
+    decode_translate_json(response, "alternative translations").await
+}
+
+async fn execute_translate_text_alignments(
+    client: &Client,
+    cookie_header: &str,
+    translate_session: &str,
+    source_text: &str,
+    target_text: &str,
+) -> Result<TextAlignmentsResponse, KagiError> {
+    let response = client
+        .post(KAGI_TRANSLATE_ALIGNMENTS_URL)
+        .header(header::COOKIE, cookie_header)
+        .header(header::CONTENT_TYPE, "application/json")
+        .json(&json!({
+            "source_text": source_text,
+            "target_text": target_text,
+            "session_token": translate_session,
+        }))
+        .send()
+        .await
+        .map_err(map_transport_error)?;
+
+    decode_translate_json(response, "text alignments").await
+}
+
+struct TranslateSuggestionContext<'a> {
+    source_text: &'a str,
+    target_text: &'a str,
+    source_language: &'a str,
+    target_language: &'a str,
+    translation_options: Option<&'a TranslateOptionState>,
+}
+
+async fn execute_translate_suggestions(
+    client: &Client,
+    cookie_header: &str,
+    translate_session: &str,
+    context: TranslateSuggestionContext<'_>,
+) -> Result<TranslationSuggestionsResponse, KagiError> {
+    let response = client
+        .post(KAGI_TRANSLATE_SUGGESTIONS_URL)
+        .header(header::COOKIE, cookie_header)
+        .header(header::CONTENT_TYPE, "application/json")
+        .json(&build_translate_suggestions_payload(context, translate_session).map(Value::Object)?)
+        .send()
+        .await
+        .map_err(map_transport_error)?;
+
+    decode_translate_json(response, "translation suggestions").await
+}
+
+async fn execute_translate_word_insights(
+    client: &Client,
+    cookie_header: &str,
+    translate_session: &str,
+    source_text: &str,
+    target_text: &str,
+    explanation_language: &str,
+    translation_options: Option<&TranslateOptionState>,
+) -> Result<WordInsightsResponse, KagiError> {
+    let response = client
+        .post(KAGI_TRANSLATE_WORD_INSIGHTS_URL)
+        .header(header::COOKIE, cookie_header)
+        .header(header::CONTENT_TYPE, "application/json")
+        .json(
+            &build_translate_word_insights_payload(
+                source_text,
+                target_text,
+                explanation_language,
+                translate_session,
+                translation_options,
+            )
+            .map(Value::Object)?,
+        )
+        .send()
+        .await
+        .map_err(map_transport_error)?;
+
+    decode_translate_json(response, "word insights").await
+}
+
+async fn capture_optional_translate_section<T, F>(
+    section: &'static str,
+    enabled: bool,
+    future: F,
+) -> (Option<T>, Option<TranslateWarning>)
+where
+    F: Future<Output = Result<T, KagiError>>,
+{
+    if !enabled {
+        return (None, None);
+    }
+
+    match future.await {
+        Ok(value) => (Some(value), None),
+        Err(error) => (
+            None,
+            Some(TranslateWarning {
+                section: section.to_string(),
+                message: error.to_string(),
+            }),
+        ),
+    }
+}
+
 fn normalize_subscriber_summary_input(
     request: &SubscriberSummarizeRequest,
 ) -> Result<(&'static str, String), KagiError> {
@@ -1190,6 +1542,340 @@ fn format_client_error_suffix(body: &str) -> String {
     format!("; {trimmed}")
 }
 
+fn build_translate_cookie_header(session_token: &str, translate_session: &str) -> String {
+    format!("kagi_session={session_token}; translate_session={translate_session}")
+}
+
+fn validate_translate_request(request: &TranslateCommandRequest) -> Result<(), KagiError> {
+    if request.text.trim().is_empty() {
+        return Err(KagiError::Config(
+            "translate text cannot be empty".to_string(),
+        ));
+    }
+
+    if request.from.trim().is_empty() {
+        return Err(KagiError::Config(
+            "translate --from cannot be empty".to_string(),
+        ));
+    }
+
+    if request.to.trim().is_empty() {
+        return Err(KagiError::Config(
+            "translate --to cannot be empty".to_string(),
+        ));
+    }
+
+    if request.to.eq_ignore_ascii_case("auto") {
+        return Err(KagiError::Config(
+            "translate --to cannot be 'auto'; pass an explicit target language code".to_string(),
+        ));
+    }
+
+    Ok(())
+}
+
+fn effective_translate_source_language(
+    requested_from: &str,
+    detected_language: &TranslateDetectedLanguage,
+) -> String {
+    if requested_from.eq_ignore_ascii_case("auto") && !detected_language.iso.trim().is_empty() {
+        detected_language.iso.clone()
+    } else {
+        requested_from.to_string()
+    }
+}
+
+fn finalize_translate_text_response(
+    mut translation: TranslateTextResponse,
+    detected_language: &TranslateDetectedLanguage,
+    effective_source_language: &str,
+    target_language: &str,
+) -> TranslateTextResponse {
+    if translation.detected_language.is_none() {
+        translation.detected_language = Some(detected_language.clone());
+    }
+    translation.source_language = Some(effective_source_language.to_string());
+    translation.target_language = Some(target_language.to_string());
+    translation
+}
+
+fn build_translate_option_state(request: &TranslateCommandRequest) -> Option<TranslateOptionState> {
+    let options = TranslateOptionState {
+        formality: request.formality.clone(),
+        speaker_gender: request.speaker_gender.clone(),
+        addressee_gender: request.addressee_gender.clone(),
+        language_complexity: request.language_complexity.clone(),
+        style: request.translation_style.clone(),
+        context: request.context.clone(),
+    };
+
+    if options.formality.is_none()
+        && options.speaker_gender.is_none()
+        && options.addressee_gender.is_none()
+        && options.language_complexity.is_none()
+        && options.style.is_none()
+        && options.context.is_none()
+    {
+        None
+    } else {
+        Some(options)
+    }
+}
+
+fn build_translate_payload(
+    request: &TranslateCommandRequest,
+    translate_session: &str,
+    effective_source_language: &str,
+) -> Value {
+    let mut payload = Map::new();
+    payload.insert("text".to_string(), Value::String(request.text.clone()));
+    payload.insert(
+        "from".to_string(),
+        Value::String(effective_source_language.to_string()),
+    );
+    payload.insert("to".to_string(), Value::String(request.to.clone()));
+    payload.insert("stream".to_string(), Value::Bool(false));
+    payload.insert(
+        "session_token".to_string(),
+        Value::String(translate_session.to_string()),
+    );
+
+    insert_optional_string(&mut payload, "quality", request.quality.as_deref());
+    insert_optional_string(&mut payload, "model", request.model.as_deref());
+    insert_optional_string(&mut payload, "prediction", request.prediction.as_deref());
+    insert_optional_string(
+        &mut payload,
+        "predicted_language",
+        request.predicted_language.as_deref(),
+    );
+    insert_optional_string(&mut payload, "formality", request.formality.as_deref());
+    insert_optional_string(
+        &mut payload,
+        "speaker_gender",
+        request.speaker_gender.as_deref(),
+    );
+    insert_optional_string(
+        &mut payload,
+        "addressee_gender",
+        request.addressee_gender.as_deref(),
+    );
+    insert_optional_string(
+        &mut payload,
+        "language_complexity",
+        request.language_complexity.as_deref(),
+    );
+    insert_optional_string(
+        &mut payload,
+        "translation_style",
+        request.translation_style.as_deref(),
+    );
+    insert_optional_string(&mut payload, "context", request.context.as_deref());
+    insert_optional_string(
+        &mut payload,
+        "dictionary_language",
+        request.dictionary_language.as_deref(),
+    );
+    insert_optional_string(&mut payload, "time_format", request.time_format.as_deref());
+    insert_optional_bool(
+        &mut payload,
+        "use_definition_context",
+        request.use_definition_context,
+    );
+    insert_optional_bool(
+        &mut payload,
+        "enable_language_features",
+        request.enable_language_features,
+    );
+    insert_optional_bool(
+        &mut payload,
+        "preserve_formatting",
+        request.preserve_formatting,
+    );
+
+    if let Some(context_memory) = &request.context_memory {
+        payload.insert(
+            "context_memory".to_string(),
+            Value::Array(context_memory.clone()),
+        );
+    }
+
+    Value::Object(payload)
+}
+
+fn build_translate_suggestions_payload(
+    context: TranslateSuggestionContext<'_>,
+    translate_session: &str,
+) -> Result<Map<String, Value>, KagiError> {
+    let mut payload = Map::new();
+    payload.insert(
+        "originalText".to_string(),
+        Value::String(context.source_text.to_string()),
+    );
+    payload.insert(
+        "translatedText".to_string(),
+        Value::String(context.target_text.to_string()),
+    );
+    payload.insert(
+        "sourceLanguage".to_string(),
+        Value::String(context.source_language.to_string()),
+    );
+    payload.insert(
+        "targetLanguage".to_string(),
+        Value::String(context.target_language.to_string()),
+    );
+    payload.insert(
+        "language".to_string(),
+        Value::String(context.target_language.to_string()),
+    );
+    payload.insert(
+        "session_token".to_string(),
+        Value::String(translate_session.to_string()),
+    );
+
+    if let Some(options) = context.translation_options {
+        payload.insert(
+            "translationOptions".to_string(),
+            serde_json::to_value(options).map_err(|error| {
+                KagiError::Parse(format!(
+                    "failed to serialize translate suggestion options: {error}"
+                ))
+            })?,
+        );
+    }
+
+    Ok(payload)
+}
+
+fn build_translate_word_insights_payload(
+    source_text: &str,
+    target_text: &str,
+    explanation_language: &str,
+    translate_session: &str,
+    translation_options: Option<&TranslateOptionState>,
+) -> Result<Map<String, Value>, KagiError> {
+    let mut payload = Map::new();
+    payload.insert(
+        "original_text".to_string(),
+        Value::String(source_text.to_string()),
+    );
+    payload.insert(
+        "translated_text".to_string(),
+        Value::String(target_text.to_string()),
+    );
+    payload.insert(
+        "target_explanation_language".to_string(),
+        Value::String(explanation_language.to_string()),
+    );
+    payload.insert(
+        "session_token".to_string(),
+        Value::String(translate_session.to_string()),
+    );
+
+    if let Some(options) = translation_options {
+        payload.insert(
+            "translation_options".to_string(),
+            serde_json::to_value(options).map_err(|error| {
+                KagiError::Parse(format!(
+                    "failed to serialize translate word-insight options: {error}"
+                ))
+            })?,
+        );
+    }
+
+    Ok(payload)
+}
+
+fn insert_optional_string(payload: &mut Map<String, Value>, key: &str, value: Option<&str>) {
+    if let Some(value) = value {
+        payload.insert(key.to_string(), Value::String(value.to_string()));
+    }
+}
+
+fn insert_optional_bool(payload: &mut Map<String, Value>, key: &str, value: Option<bool>) {
+    if let Some(value) = value {
+        payload.insert(key.to_string(), Value::Bool(value));
+    }
+}
+
+fn normalize_aux_quality(raw: Option<&str>) -> Option<String> {
+    raw.map(|value| {
+        if value == "best" || value.starts_with("deep_") {
+            "best".to_string()
+        } else {
+            "standard".to_string()
+        }
+    })
+}
+
+fn parse_translate_detect_value(value: Value) -> Result<TranslateDetectedLanguage, KagiError> {
+    let candidate = match value {
+        Value::Array(mut values) => values.drain(..).next().ok_or_else(|| {
+            KagiError::Parse(
+                "failed to parse translate language detection response: empty array".to_string(),
+            )
+        })?,
+        Value::Object(_) => value,
+        other => {
+            return Err(KagiError::Parse(format!(
+                "failed to parse translate language detection response: unexpected payload {other}"
+            )));
+        }
+    };
+
+    serde_json::from_value(candidate).map_err(|error| {
+        KagiError::Parse(format!(
+            "failed to parse translate language detection response: {error}"
+        ))
+    })
+}
+
+fn extract_set_cookie_value(headers: &header::HeaderMap, name: &str) -> Option<String> {
+    let prefix = format!("{name}=");
+
+    headers
+        .get_all(header::SET_COOKIE)
+        .iter()
+        .find_map(|value| {
+            let raw = value.to_str().ok()?;
+            let cookie = raw.strip_prefix(&prefix)?;
+            cookie
+                .split(';')
+                .next()
+                .filter(|value| !value.is_empty())
+                .map(str::to_string)
+        })
+}
+
+fn resolve_translate_bootstrap(
+    status: StatusCode,
+    headers: &header::HeaderMap,
+) -> Result<TranslateBootstrapResult, KagiError> {
+    match status {
+        StatusCode::OK => {
+            let translate_session = extract_set_cookie_value(headers, "translate_session")
+                .ok_or_else(|| {
+                    KagiError::Auth(
+                        "translate bootstrap did not mint a translate_session cookie".to_string(),
+                    )
+                })?;
+
+            Ok(TranslateBootstrapResult {
+                translate_session,
+                method: "reqwest(set-cookie bootstrap)".to_string(),
+            })
+        }
+        StatusCode::UNAUTHORIZED | StatusCode::FORBIDDEN => Err(KagiError::Auth(
+            "invalid or expired Kagi session token for Kagi Translate".to_string(),
+        )),
+        status if status.is_server_error() => Err(KagiError::Network(format!(
+            "Kagi Translate bootstrap server error: HTTP {status}"
+        ))),
+        status => Err(KagiError::Network(format!(
+            "unexpected Kagi Translate bootstrap response status: HTTP {status}"
+        ))),
+    }
+}
+
 fn normalize_ask_page_url(raw: &str) -> Result<String, KagiError> {
     let trimmed = raw.trim();
     if trimmed.is_empty() {
@@ -1223,10 +1909,20 @@ fn build_ask_page_prompt(url: &str, question: &str) -> String {
     format!("{url}\n{question}")
 }
 
+#[cfg(test)]
+fn fake_header_map(set_cookies: &[&str]) -> header::HeaderMap {
+    let mut headers = header::HeaderMap::new();
+    for value in set_cookies {
+        headers.append(
+            header::SET_COOKIE,
+            header::HeaderValue::from_str(value).expect("header value should parse"),
+        );
+    }
+    headers
+}
+
 #[derive(Debug, Deserialize)]
 struct ApiErrorBody {
-    #[allow(dead_code)]
-    meta: Option<serde_json::Value>,
     error: Option<Vec<ApiErrorItem>>,
 }
 
@@ -1333,6 +2029,12 @@ struct AssistantThreadListPayload {
     total_counts: HashMap<String, u64>,
 }
 
+#[derive(Debug)]
+struct TranslateBootstrapResult {
+    translate_session: String,
+    method: String,
+}
+
 async fn decode_kagi_json<T>(response: reqwest::Response, surface: &str) -> Result<T, KagiError>
 where
     T: DeserializeOwned,
@@ -1399,6 +2101,50 @@ where
     }
 }
 
+async fn decode_translate_json<T>(
+    response: reqwest::Response,
+    surface: &str,
+) -> Result<T, KagiError>
+where
+    T: DeserializeOwned,
+{
+    match response.status() {
+        StatusCode::OK => {
+            let body = response.text().await.map_err(|error| {
+                KagiError::Network(format!(
+                    "failed to read Kagi Translate {surface} response body: {error}"
+                ))
+            })?;
+            if looks_like_html_document(&body) {
+                return Err(KagiError::Auth(
+                    "invalid or expired Kagi session token for Kagi Translate".to_string(),
+                ));
+            }
+            serde_json::from_str(&body).map_err(|error| {
+                KagiError::Parse(format!(
+                    "failed to parse Kagi Translate {surface} response: {error}"
+                ))
+            })
+        }
+        StatusCode::UNAUTHORIZED | StatusCode::FORBIDDEN => Err(KagiError::Auth(
+            "invalid or expired Kagi session token for Kagi Translate".to_string(),
+        )),
+        status if status.is_client_error() => {
+            let body = response.text().await.unwrap_or_else(|_| String::new());
+            Err(KagiError::Config(format!(
+                "Kagi Translate {surface} request rejected: HTTP {status}{}",
+                format_client_error_suffix(&body)
+            )))
+        }
+        status if status.is_server_error() => Err(KagiError::Network(format!(
+            "Kagi Translate {surface} server error: HTTP {status}"
+        ))),
+        status => Err(KagiError::Network(format!(
+            "unexpected Kagi Translate {surface} response status: HTTP {status}"
+        ))),
+    }
+}
+
 fn build_client() -> Result<Client, KagiError> {
     Client::builder()
         .user_agent(USER_AGENT)
@@ -1429,26 +2175,81 @@ pub struct KagiEnvelope<T> {
 #[cfg(test)]
 mod tests {
     use super::{
-        ApiErrorBody, KagiEnvelope, build_ask_page_prompt, normalize_ask_page_question,
-        normalize_ask_page_url, normalize_assistant_query, normalize_assistant_thread_id,
+        ApiErrorBody, KagiEnvelope, TranslateSuggestionContext, build_ask_page_prompt,
+        build_translate_option_state, build_translate_payload, build_translate_suggestions_payload,
+        build_translate_word_insights_payload, capture_optional_translate_section,
+        effective_translate_source_language, extract_set_cookie_value, fake_header_map,
+        finalize_translate_text_response, normalize_ask_page_question, normalize_ask_page_url,
+        normalize_assistant_query, normalize_assistant_thread_id, normalize_aux_quality,
         normalize_subscriber_summary_input, normalize_subscriber_summary_length,
         normalize_subscriber_summary_type, parse_assistant_prompt_stream,
         parse_assistant_thread_delete_stream, parse_assistant_thread_list_stream,
         parse_assistant_thread_open_stream, parse_content_disposition_filename,
-        parse_subscriber_summarize_stream, resolve_news_category,
+        parse_subscriber_summarize_stream, parse_translate_detect_value, resolve_news_category,
+        resolve_translate_bootstrap, validate_translate_request,
     };
     use crate::api::{
         execute_assistant_prompt, execute_assistant_thread_delete, execute_assistant_thread_export,
         execute_assistant_thread_get, execute_assistant_thread_list,
     };
-    use crate::auth::{SESSION_TOKEN_ENV, load_credential_inventory};
+    use crate::auth::{SESSION_TOKEN_ENV, load_credential_inventory, normalize_session_token};
     use crate::types::{AskPageRequest, SubscriberSummarizeRequest};
     use crate::types::{
         AssistantPromptRequest, FastGptAnswer, NewsBatchCategory, NewsCategoryMetadata, Reference,
-        Summarization,
+        Summarization, TranslateCommandRequest, TranslateDetectedLanguage, TranslateTextResponse,
+    };
+    use reqwest::StatusCode;
+    use serde_json::{Value, json};
+    use std::sync::{
+        Arc,
+        atomic::{AtomicBool, Ordering},
     };
     use std::time::{SystemTime, UNIX_EPOCH};
 
+    fn sample_translate_request() -> TranslateCommandRequest {
+        TranslateCommandRequest {
+            text: "Bonjour".to_string(),
+            from: "auto".to_string(),
+            to: "en".to_string(),
+            quality: None,
+            model: None,
+            prediction: None,
+            predicted_language: None,
+            formality: None,
+            speaker_gender: None,
+            addressee_gender: None,
+            language_complexity: None,
+            translation_style: None,
+            context: None,
+            dictionary_language: None,
+            time_format: None,
+            use_definition_context: None,
+            enable_language_features: None,
+            preserve_formatting: None,
+            context_memory: None,
+            fetch_alternatives: true,
+            fetch_word_insights: true,
+            fetch_suggestions: true,
+            fetch_alignments: true,
+        }
+    }
+
+    fn sample_detected_language() -> TranslateDetectedLanguage {
+        TranslateDetectedLanguage {
+            iso: "fr".to_string(),
+            label: "French".to_string(),
+            is_uncertain: false,
+            is_mixed: false,
+            alternatives: vec![],
+        }
+    }
+
+    fn live_translate_session_token() -> Option<String> {
+        std::env::var("KAGI_SESSION_TOKEN")
+            .ok()
+            .and_then(|value| normalize_session_token(&value).ok())
+    }
+
     #[test]
     fn parses_summarize_envelope() {
         let raw = r#"{
@@ -1884,4 +2685,458 @@ mod tests {
             .to_ascii_lowercase();
         assert!(answer.contains("rust"));
     }
+
+    #[test]
+    fn parses_translate_detect_from_object_or_array() {
+        let object = json!({
+            "iso": "fr",
+            "label": "French",
+            "isUncertain": false,
+            "isMixed": false
+        });
+        let array = json!([
+            {
+                "iso": "fr",
+                "label": "French",
+                "isUncertain": false,
+                "isMixed": false
+            }
+        ]);
+
+        let parsed_object = parse_translate_detect_value(object).expect("object should parse");
+        let parsed_array = parse_translate_detect_value(array).expect("array should parse");
+
+        assert_eq!(parsed_object.iso, "fr");
+        assert_eq!(parsed_array.label, "French");
+    }
+
+    #[test]
+    fn rejects_empty_translate_detect_array() {
+        let error = parse_translate_detect_value(Value::Array(vec![]))
+            .expect_err("empty array should fail");
+        assert!(error.to_string().contains("empty array"));
+    }
+
+    #[test]
+    fn rejects_translate_target_auto_value() {
+        let mut request = sample_translate_request();
+        request.to = "auto".to_string();
+
+        let error = validate_translate_request(&request).expect_err("auto target should fail");
+        assert!(error.to_string().contains("explicit target language code"));
+    }
+
+    #[test]
+    fn rejects_empty_translate_text() {
+        let mut request = sample_translate_request();
+        request.text = "   ".to_string();
+
+        let error = validate_translate_request(&request).expect_err("empty text should fail");
+        assert!(error.to_string().contains("translate text cannot be empty"));
+    }
+
+    #[test]
+    fn rejects_empty_translate_source_language() {
+        let mut request = sample_translate_request();
+        request.from = "   ".to_string();
+
+        let error = validate_translate_request(&request).expect_err("empty source should fail");
+        assert!(
+            error
+                .to_string()
+                .contains("translate --from cannot be empty")
+        );
+    }
+
+    #[test]
+    fn rejects_empty_translate_target_language() {
+        let mut request = sample_translate_request();
+        request.to = "   ".to_string();
+
+        let error = validate_translate_request(&request).expect_err("empty target should fail");
+        assert!(error.to_string().contains("translate --to cannot be empty"));
+    }
+
+    #[test]
+    fn extracts_translate_session_from_set_cookie_headers() {
+        let headers = fake_header_map(&[
+            "translate_language=en; Max-Age=31536000; Path=/; HttpOnly; Secure; SameSite=Lax",
+            "translate_session=abc.def.ghi; Path=/; Expires=Wed, 18 Mar 2026 23:41:41 GMT; HttpOnly; Secure; SameSite=Lax",
+        ]);
+
+        let cookie = extract_set_cookie_value(&headers, "translate_session");
+
+        assert_eq!(cookie.as_deref(), Some("abc.def.ghi"));
+    }
+
+    #[test]
+    fn returns_none_when_set_cookie_name_is_missing() {
+        let headers = fake_header_map(&[
+            "translate_language=en; Max-Age=31536000; Path=/; HttpOnly; Secure; SameSite=Lax",
+        ]);
+
+        assert_eq!(
+            extract_set_cookie_value(&headers, "translate_session"),
+            None
+        );
+    }
+
+    #[test]
+    fn resolves_translate_bootstrap_from_success_cookie() {
+        let headers = fake_header_map(&[
+            "translate_session=abc.def.ghi; Path=/; HttpOnly; Secure; SameSite=Lax",
+        ]);
+
+        let bootstrap =
+            resolve_translate_bootstrap(StatusCode::OK, &headers).expect("bootstrap resolves");
+
+        assert_eq!(bootstrap.translate_session, "abc.def.ghi");
+        assert_eq!(bootstrap.method, "reqwest(set-cookie bootstrap)");
+    }
+
+    #[test]
+    fn rejects_translate_bootstrap_success_without_cookie() {
+        let headers = fake_header_map(&[]);
+
+        let error = resolve_translate_bootstrap(StatusCode::OK, &headers)
+            .expect_err("missing cookie should fail");
+
+        assert!(
+            error
+                .to_string()
+                .contains("did not mint a translate_session cookie")
+        );
+    }
+
+    #[test]
+    fn maps_translate_bootstrap_auth_statuses() {
+        let headers = fake_header_map(&[]);
+
+        for status in [StatusCode::UNAUTHORIZED, StatusCode::FORBIDDEN] {
+            let error =
+                resolve_translate_bootstrap(status, &headers).expect_err("auth status should fail");
+            assert!(
+                error
+                    .to_string()
+                    .contains("invalid or expired Kagi session token")
+            );
+        }
+    }
+
+    #[test]
+    fn uses_detected_source_language_when_translate_from_is_auto() {
+        let source = effective_translate_source_language("auto", &sample_detected_language());
+        assert_eq!(source, "fr");
+    }
+
+    #[test]
+    fn preserves_explicit_translate_source_language() {
+        let source = effective_translate_source_language("es", &sample_detected_language());
+        assert_eq!(source, "es");
+    }
+
+    #[test]
+    fn falls_back_to_requested_source_when_detected_iso_is_empty() {
+        let detected_language = TranslateDetectedLanguage {
+            iso: String::new(),
+            label: "Unknown".to_string(),
+            is_uncertain: true,
+            is_mixed: false,
+            alternatives: vec![],
+        };
+
+        let source = effective_translate_source_language("auto", &detected_language);
+
+        assert_eq!(source, "auto");
+    }
+
+    #[test]
+    fn backfills_translate_language_metadata() {
+        let translation = TranslateTextResponse {
+            translation: "Hello everyone".to_string(),
+            source_language: None,
+            target_language: None,
+            detected_language: None,
+            definition: None,
+        };
+
+        let finalized =
+            finalize_translate_text_response(translation, &sample_detected_language(), "fr", "en");
+
+        assert_eq!(finalized.source_language.as_deref(), Some("fr"));
+        assert_eq!(finalized.target_language.as_deref(), Some("en"));
+        assert_eq!(
+            finalized
+                .detected_language
+                .as_ref()
+                .map(|value| value.iso.as_str()),
+            Some("fr")
+        );
+    }
+
+    #[test]
+    fn keeps_existing_translate_detected_language_when_present() {
+        let translation = TranslateTextResponse {
+            translation: "Hello everyone".to_string(),
+            source_language: None,
+            target_language: None,
+            detected_language: Some(TranslateDetectedLanguage {
+                iso: "es".to_string(),
+                label: "Spanish".to_string(),
+                is_uncertain: false,
+                is_mixed: false,
+                alternatives: vec![],
+            }),
+            definition: None,
+        };
+
+        let finalized =
+            finalize_translate_text_response(translation, &sample_detected_language(), "fr", "en");
+
+        assert_eq!(
+            finalized
+                .detected_language
+                .as_ref()
+                .map(|value| value.iso.as_str()),
+            Some("es")
+        );
+    }
+
+    #[test]
+    fn omits_empty_translate_option_state() {
+        assert!(build_translate_option_state(&sample_translate_request()).is_none());
+    }
+
+    #[test]
+    fn builds_translate_payload_with_optional_fields() {
+        let request = TranslateCommandRequest {
+            text: "Bonjour".to_string(),
+            from: "auto".to_string(),
+            to: "en".to_string(),
+            quality: Some("best".to_string()),
+            model: Some("kagi".to_string()),
+            prediction: Some("Hello".to_string()),
+            predicted_language: Some("fr".to_string()),
+            formality: Some("formal".to_string()),
+            speaker_gender: Some("female".to_string()),
+            addressee_gender: Some("male".to_string()),
+            language_complexity: Some("simple".to_string()),
+            translation_style: Some("natural".to_string()),
+            context: Some("Office email".to_string()),
+            dictionary_language: Some("en".to_string()),
+            time_format: Some("24h".to_string()),
+            use_definition_context: Some(true),
+            enable_language_features: Some(true),
+            preserve_formatting: Some(true),
+            context_memory: Some(vec![json!({"kind": "glossary"})]),
+            fetch_alternatives: true,
+            fetch_word_insights: true,
+            fetch_suggestions: true,
+            fetch_alignments: true,
+        };
+
+        let payload = build_translate_payload(&request, "translate-session", "fr");
+        let object = payload.as_object().expect("payload should be object");
+
+        assert_eq!(object.get("from"), Some(&Value::String("fr".to_string())));
+        assert_eq!(
+            object.get("translation_style"),
+            Some(&Value::String("natural".to_string()))
+        );
+        assert_eq!(
+            object.get("context_memory"),
+            Some(&Value::Array(vec![json!({"kind": "glossary"})]))
+        );
+        assert_eq!(
+            object.get("session_token"),
+            Some(&Value::String("translate-session".to_string()))
+        );
+    }
+
+    #[test]
+    fn localizes_translate_suggestions_payload_to_target_language() {
+        let payload = build_translate_suggestions_payload(
+            TranslateSuggestionContext {
+                source_text: "Bonjour tout le monde",
+                target_text: "みなさん、こんにちは",
+                source_language: "fr",
+                target_language: "ja",
+                translation_options: None,
+            },
+            "translate-session",
+        )
+        .expect("payload should build");
+
+        assert_eq!(
+            payload.get("language"),
+            Some(&Value::String("ja".to_string()))
+        );
+    }
+
+    #[test]
+    fn localizes_translate_word_insights_payload_to_target_language() {
+        let payload = build_translate_word_insights_payload(
+            "Bonjour tout le monde",
+            "みなさん、こんにちは",
+            "ja",
+            "translate-session",
+            None,
+        )
+        .expect("payload should build");
+
+        assert_eq!(
+            payload.get("target_explanation_language"),
+            Some(&Value::String("ja".to_string()))
+        );
+    }
+
+    #[test]
+    fn normalizes_aux_quality_values() {
+        assert_eq!(normalize_aux_quality(None), None);
+        assert_eq!(normalize_aux_quality(Some("best")).as_deref(), Some("best"));
+        assert_eq!(
+            normalize_aux_quality(Some("deep_contextual")).as_deref(),
+            Some("best")
+        );
+        assert_eq!(
+            normalize_aux_quality(Some("standard")).as_deref(),
+            Some("standard")
+        );
+    }
+
+    #[tokio::test]
+    async fn skips_disabled_translate_optional_sections_without_polling() {
+        let polled = Arc::new(AtomicBool::new(false));
+        let future_polled = Arc::clone(&polled);
+
+        let (value, warning) =
+            capture_optional_translate_section("word_insights", false, async move {
+                future_polled.store(true, Ordering::SeqCst);
+                Ok::<_, crate::error::KagiError>("value")
+            })
+            .await;
+
+        assert!(value.is_none());
+        assert!(warning.is_none());
+        assert!(!polled.load(Ordering::SeqCst));
+    }
+
+    #[tokio::test]
+    async fn captures_translate_optional_section_failures_as_warnings() {
+        let (value, warning) = capture_optional_translate_section("word_insights", true, async {
+            Err::<Value, _>(crate::error::KagiError::Network(
+                "temporary upstream failure".to_string(),
+            ))
+        })
+        .await;
+
+        assert!(value.is_none());
+        let warning = warning.expect("warning should be returned");
+        assert_eq!(warning.section, "word_insights");
+        assert!(warning.message.contains("temporary upstream failure"));
+    }
+
+    #[tokio::test]
+    #[ignore = "requires live KAGI_SESSION_TOKEN"]
+    async fn live_translate_populates_language_metadata_and_sections() {
+        let token = live_translate_session_token().expect("set KAGI_SESSION_TOKEN for live tests");
+        let request = TranslateCommandRequest {
+            text: "Bonjour tout le monde".to_string(),
+            ..sample_translate_request()
+        };
+
+        let response = super::execute_translate(&request, &token)
+            .await
+            .expect("live translate should succeed");
+
+        assert_eq!(response.detected_language.iso, "fr");
+        assert_eq!(response.translation.source_language.as_deref(), Some("fr"));
+        assert_eq!(response.translation.target_language.as_deref(), Some("en"));
+        assert!(!response.translation.translation.trim().is_empty());
+
+        for (section, present) in [
+            ("alternatives", response.alternatives.is_some()),
+            ("text_alignments", response.text_alignments.is_some()),
+            (
+                "translation_suggestions",
+                response.translation_suggestions.is_some(),
+            ),
+            ("word_insights", response.word_insights.is_some()),
+        ] {
+            let warned = response
+                .warnings
+                .iter()
+                .any(|warning| warning.section == section);
+            assert!(
+                present || warned,
+                "expected {section} to be present or downgraded to a warning"
+            );
+        }
+    }
+
+    #[tokio::test]
+    #[ignore = "requires live KAGI_SESSION_TOKEN"]
+    async fn live_translate_core_only_skips_auxiliary_sections() {
+        let token = live_translate_session_token().expect("set KAGI_SESSION_TOKEN for live tests");
+        let request = TranslateCommandRequest {
+            text: "Bonjour tout le monde".to_string(),
+            to: "ja".to_string(),
+            fetch_alternatives: false,
+            fetch_word_insights: false,
+            fetch_suggestions: false,
+            fetch_alignments: false,
+            ..sample_translate_request()
+        };
+
+        let response = super::execute_translate(&request, &token)
+            .await
+            .expect("live translate should succeed");
+
+        assert_eq!(response.translation.source_language.as_deref(), Some("fr"));
+        assert_eq!(response.translation.target_language.as_deref(), Some("ja"));
+        assert!(response.alternatives.is_none());
+        assert!(response.text_alignments.is_none());
+        assert!(response.translation_suggestions.is_none());
+        assert!(response.word_insights.is_none());
+        assert!(response.warnings.is_empty());
+    }
+
+    #[tokio::test]
+    #[ignore = "requires live KAGI_SESSION_TOKEN"]
+    async fn live_translate_localizes_auxiliary_metadata_for_non_english_targets() {
+        let token = live_translate_session_token().expect("set KAGI_SESSION_TOKEN for live tests");
+        let request = TranslateCommandRequest {
+            text: "Bonjour tout le monde".to_string(),
+            to: "ja".to_string(),
+            ..sample_translate_request()
+        };
+
+        let response = super::execute_translate(&request, &token)
+            .await
+            .expect("live translate should succeed");
+
+        let suggestions = response
+            .translation_suggestions
+            .as_ref()
+            .expect("suggestions should be present for ja target");
+        let insights = response
+            .word_insights
+            .as_ref()
+            .expect("word insights should be present for ja target");
+
+        assert!(
+            suggestions
+                .suggestions
+                .iter()
+                .any(|entry| !entry.label.is_ascii()),
+            "expected at least one localized suggestion label"
+        );
+        assert!(
+            insights
+                .insights
+                .iter()
+                .any(|entry| !entry.r#type.is_ascii()),
+            "expected at least one localized insight type"
+        );
+    }
 }
diff --git a/src/auth.rs b/src/auth.rs
index 2dc23ea..80dc38a 100644
--- a/src/auth.rs
+++ b/src/auth.rs
@@ -276,7 +276,7 @@ fn build_session_credential(
     Ok(Credential {
         kind: CredentialKind::SessionToken,
         source,
-        value: normalize_session_token_input(raw_value)?,
+        value: normalize_session_token(raw_value)?,
     })
 }
 
@@ -303,7 +303,7 @@ pub fn save_credentials(
     }
 
     if let Some(session_input) = session_input {
-        let normalized = normalize_session_token_input(session_input)?;
+        let normalized = normalize_session_token(session_input)?;
         auth.session_token = Some(normalized);
     }
 
@@ -323,7 +323,14 @@ pub fn save_credentials(
     load_credential_inventory()
 }
 
-fn normalize_session_token_input(input: &str) -> Result<String, KagiError> {
+#[cfg(test)]
+fn normalize_optional_session_token(input: Option<String>) -> Result<Option<String>, KagiError> {
+    input
+        .map(|value| normalize_session_token(&value))
+        .transpose()
+}
+
+pub fn normalize_session_token(input: &str) -> Result<String, KagiError> {
     let trimmed = input.trim();
     if trimmed.is_empty() {
         return Err(KagiError::Config(
@@ -615,15 +622,14 @@ mod tests {
 
     #[test]
     fn extracts_token_from_session_link_url() {
-        let token =
-            normalize_session_token_input("https://kagi.com/search?token=abc123.def456&foo=bar")
-                .expect("session link parses");
+        let token = normalize_session_token("https://kagi.com/search?token=abc123.def456&foo=bar")
+            .expect("session link parses");
         assert_eq!(token, "abc123.def456");
     }
 
     #[test]
     fn keeps_raw_session_token_input() {
-        let token = normalize_session_token_input("abc123.def456").expect("raw token accepted");
+        let token = normalize_session_token("abc123.def456").expect("raw token accepted");
         assert_eq!(token, "abc123.def456");
     }
 
@@ -655,8 +661,18 @@ mod tests {
 
     #[test]
     fn rejects_session_link_without_token_param() {
-        let error = normalize_session_token_input("https://kagi.com/search?q=test")
+        let error = normalize_session_token("https://kagi.com/search?q=test")
             .expect_err("missing token param should fail");
         assert!(error.to_string().contains("token="));
     }
+
+    #[test]
+    fn normalizes_session_link_from_environment_style_input() {
+        let normalized = normalize_optional_session_token(Some(
+            "https://kagi.com/search?token=env-session-token".to_string(),
+        ))
+        .expect("session token should normalize");
+
+        assert_eq!(normalized.as_deref(), Some("env-session-token"));
+    }
 }
diff --git a/src/cli.rs b/src/cli.rs
index d618b9e..026561e 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -106,6 +106,8 @@ pub enum Commands {
     Assistant(AssistantArgs),
     /// Ask Kagi Assistant about a specific web page
     AskPage(AskPageArgs),
+    /// Translate text through Kagi Translate using session-token auth
+    Translate(Box<TranslateArgs>),
     /// Answer a query with Kagi's FastGPT API
     Fastgpt(FastGptArgs),
     /// Query Kagi's enrichment indexes
@@ -445,6 +447,101 @@ pub struct AskPageArgs {
     pub question: String,
 }
 
+#[derive(Debug, Args)]
+pub struct TranslateArgs {
+    /// Text to translate
+    #[arg(value_name = "TEXT")]
+    pub text: String,
+
+    /// Source language code (default: auto)
+    #[arg(long, value_name = "LANG", default_value = "auto")]
+    pub from: String,
+
+    /// Target language code (default: en)
+    #[arg(long, value_name = "LANG", default_value = "en")]
+    pub to: String,
+
+    /// Translation quality preference
+    #[arg(long, value_name = "QUALITY")]
+    pub quality: Option<String>,
+
+    /// Translation model override
+    #[arg(long, value_name = "MODEL")]
+    pub model: Option<String>,
+
+    /// Prediction text to bias the translation
+    #[arg(long, value_name = "TEXT")]
+    pub prediction: Option<String>,
+
+    /// Predicted source language code
+    #[arg(long, value_name = "LANG")]
+    pub predicted_language: Option<String>,
+
+    /// Formality setting
+    #[arg(long, value_name = "LEVEL")]
+    pub formality: Option<String>,
+
+    /// Speaker gender hint
+    #[arg(long, value_name = "GENDER")]
+    pub speaker_gender: Option<String>,
+
+    /// Addressee gender hint
+    #[arg(long, value_name = "GENDER")]
+    pub addressee_gender: Option<String>,
+
+    /// Language complexity setting
+    #[arg(long, value_name = "LEVEL")]
+    pub language_complexity: Option<String>,
+
+    /// Translation style setting
+    #[arg(long, value_name = "STYLE")]
+    pub translation_style: Option<String>,
+
+    /// Extra translation context
+    #[arg(long, value_name = "TEXT")]
+    pub context: Option<String>,
+
+    /// Dictionary language override
+    #[arg(long, value_name = "LANG")]
+    pub dictionary_language: Option<String>,
+
+    /// Time formatting style
+    #[arg(long, value_name = "FORMAT")]
+    pub time_format: Option<String>,
+
+    /// Toggle definition-aware translation behavior
+    #[arg(long)]
+    pub use_definition_context: Option<bool>,
+
+    /// Toggle language-feature enrichment
+    #[arg(long)]
+    pub enable_language_features: Option<bool>,
+
+    /// Preserve source formatting when possible
+    #[arg(long)]
+    pub preserve_formatting: Option<bool>,
+
+    /// Raw JSON array passed through as context_memory
+    #[arg(long, value_name = "JSON")]
+    pub context_memory_json: Option<String>,
+
+    /// Skip the alternative translations call
+    #[arg(long)]
+    pub no_alternatives: bool,
+
+    /// Skip the word insights call
+    #[arg(long)]
+    pub no_word_insights: bool,
+
+    /// Skip the translation suggestions call
+    #[arg(long)]
+    pub no_suggestions: bool,
+
+    /// Skip the text alignments call
+    #[arg(long)]
+    pub no_alignments: bool,
+}
+
 #[derive(Debug, Args)]
 pub struct EnrichCommand {
     #[command(subcommand)]
diff --git a/src/main.rs b/src/main.rs
index 5cccd2c..7c3fd4a 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -14,7 +14,7 @@ use crate::api::{
     execute_assistant_thread_export, execute_assistant_thread_get, execute_assistant_thread_list,
     execute_enrich_news, execute_enrich_web, execute_fastgpt, execute_news,
     execute_news_categories, execute_news_chaos, execute_smallweb, execute_subscriber_summarize,
-    execute_summarize,
+    execute_summarize, execute_translate,
 };
 use crate::auth::{
     Credential, CredentialKind, SearchAuthRequirement, SearchCredentials, format_status,
@@ -23,12 +23,14 @@ use crate::auth::{
 use crate::cli::{
     AssistantSubcommand, AssistantThreadExportFormat, AssistantThreadSubcommand, AuthSetArgs,
     AuthSubcommand, Cli, Commands, CompletionShell, EnrichSubcommand, SearchOrder, SearchTime,
+    TranslateArgs,
 };
 use crate::error::KagiError;
 use crate::types::{
     AskPageRequest, AssistantPromptRequest, FastGptRequest, SearchResponse,
-    SubscriberSummarizeRequest, SummarizeRequest,
+    SubscriberSummarizeRequest, SummarizeRequest, TranslateCommandRequest,
 };
+use serde_json::Value;
 use std::sync::Arc;
 use std::time::{Duration, Instant};
 use tokio::sync::Semaphore;
@@ -222,6 +224,12 @@ async fn run() -> Result<(), KagiError> {
             let response = execute_ask_page(&request, &token).await?;
             print_json(&response)
         }
+        Commands::Translate(args) => {
+            let token = resolve_session_token()?;
+            let request = build_translate_request(*args)?;
+            let response = execute_translate(&request, &token).await?;
+            print_json(&response)
+        }
         Commands::Fastgpt(args) => {
             let request = FastGptRequest {
                 query: args.query,
@@ -377,6 +385,59 @@ fn resolve_session_token() -> Result<String, KagiError> {
         })
 }
 
+fn build_translate_request(args: TranslateArgs) -> Result<TranslateCommandRequest, KagiError> {
+    Ok(TranslateCommandRequest {
+        text: args.text.trim().to_string(),
+        from: args.from.trim().to_string(),
+        to: args.to.trim().to_string(),
+        quality: normalize_optional_string(args.quality),
+        model: normalize_optional_string(args.model),
+        prediction: normalize_optional_string(args.prediction),
+        predicted_language: normalize_optional_string(args.predicted_language),
+        formality: normalize_optional_string(args.formality),
+        speaker_gender: normalize_optional_string(args.speaker_gender),
+        addressee_gender: normalize_optional_string(args.addressee_gender),
+        language_complexity: normalize_optional_string(args.language_complexity),
+        translation_style: normalize_optional_string(args.translation_style),
+        context: normalize_optional_string(args.context),
+        dictionary_language: normalize_optional_string(args.dictionary_language),
+        time_format: normalize_optional_string(args.time_format),
+        use_definition_context: args.use_definition_context,
+        enable_language_features: args.enable_language_features,
+        preserve_formatting: args.preserve_formatting,
+        context_memory: parse_context_memory_json(args.context_memory_json.as_deref())?,
+        fetch_alternatives: !args.no_alternatives,
+        fetch_word_insights: !args.no_word_insights,
+        fetch_suggestions: !args.no_suggestions,
+        fetch_alignments: !args.no_alignments,
+    })
+}
+
+fn normalize_optional_string(value: Option<String>) -> Option<String> {
+    value
+        .map(|value| value.trim().to_string())
+        .filter(|value| !value.is_empty())
+}
+
+fn parse_context_memory_json(raw: Option<&str>) -> Result<Option<Vec<Value>>, KagiError> {
+    let Some(raw) = raw.map(str::trim).filter(|value| !value.is_empty()) else {
+        return Ok(None);
+    };
+
+    let parsed: Value = serde_json::from_str(raw).map_err(|error| {
+        KagiError::Config(format!(
+            "--context-memory-json must be valid JSON; parse failed: {error}"
+        ))
+    })?;
+
+    match parsed {
+        Value::Array(values) => Ok(Some(values)),
+        _ => Err(KagiError::Config(
+            "--context-memory-json must be a JSON array".to_string(),
+        )),
+    }
+}
+
 fn build_search_request(query: String, options: &SearchRequestOptions) -> search::SearchRequest {
     let mut request = search::SearchRequest::new(query);
 
@@ -720,11 +781,13 @@ async fn run_batch_search(
 mod tests {
     use super::{
         RateLimiter, SearchRequestOptions, build_search_request, format_csv_response,
-        format_markdown_response, format_pretty_response, should_fallback_to_session,
+        format_markdown_response, format_pretty_response, parse_context_memory_json,
+        should_fallback_to_session,
     };
     use crate::cli::{SearchOrder, SearchTime};
     use crate::error::KagiError;
     use crate::types::{SearchResponse, SearchResult};
+    use serde_json::json;
     use std::sync::Arc;
     use std::time::{Duration, Instant};
 
@@ -965,4 +1028,23 @@ mod tests {
             "request to Kagi timed out".to_string(),
         )));
     }
+
+    #[test]
+    fn parses_context_memory_array_json() {
+        let parsed = parse_context_memory_json(Some(r#"[{"kind":"glossary","value":"hello"}]"#))
+            .expect("context memory should parse");
+
+        assert_eq!(
+            parsed,
+            Some(vec![json!({"kind": "glossary", "value": "hello"})])
+        );
+    }
+
+    #[test]
+    fn rejects_non_array_context_memory_json() {
+        let error = parse_context_memory_json(Some(r#"{"kind":"glossary"}"#))
+            .expect_err("object context memory should fail");
+
+        assert!(error.to_string().contains("JSON array"));
+    }
 }
diff --git a/src/types.rs b/src/types.rs
index a16d2af..889ec64 100644
--- a/src/types.rs
+++ b/src/types.rs
@@ -412,3 +412,184 @@ pub struct EnrichResponse {
 pub struct SmallWebFeed {
     pub xml: String,
 }
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct TranslateCommandRequest {
+    pub text: String,
+    pub from: String,
+    pub to: String,
+    pub quality: Option<String>,
+    pub model: Option<String>,
+    pub prediction: Option<String>,
+    pub predicted_language: Option<String>,
+    pub formality: Option<String>,
+    pub speaker_gender: Option<String>,
+    pub addressee_gender: Option<String>,
+    pub language_complexity: Option<String>,
+    pub translation_style: Option<String>,
+    pub context: Option<String>,
+    pub dictionary_language: Option<String>,
+    pub time_format: Option<String>,
+    pub use_definition_context: Option<bool>,
+    pub enable_language_features: Option<bool>,
+    pub preserve_formatting: Option<bool>,
+    pub context_memory: Option<Vec<Value>>,
+    pub fetch_alternatives: bool,
+    pub fetch_word_insights: bool,
+    pub fetch_suggestions: bool,
+    pub fetch_alignments: bool,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
+pub struct TranslateOptionState {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub formality: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub speaker_gender: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub addressee_gender: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub language_complexity: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub style: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub context: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct TranslateBootstrapMetadata {
+    pub method: String,
+    pub authenticated: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct TranslateWarning {
+    pub section: String,
+    pub message: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct TranslateDetectedLanguageAlternative {
+    pub iso: String,
+    pub label: String,
+    #[serde(default, rename = "isUncertain")]
+    pub is_uncertain: bool,
+    #[serde(default, rename = "isMixed")]
+    pub is_mixed: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct TranslateDetectedLanguage {
+    pub iso: String,
+    pub label: String,
+    #[serde(default, rename = "isUncertain")]
+    pub is_uncertain: bool,
+    #[serde(default, rename = "isMixed")]
+    pub is_mixed: bool,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub alternatives: Vec<TranslateDetectedLanguageAlternative>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct TranslateTextResponse {
+    pub translation: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub source_language: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub target_language: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub detected_language: Option<TranslateDetectedLanguage>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub definition: Option<Value>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct AlternativeTranslationElement {
+    pub translation: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub explanation: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct AlternativeTranslationsResponse {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub original_description: Option<String>,
+    #[serde(default)]
+    pub elements: Vec<AlternativeTranslationElement>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct TextAlignmentsResponse {
+    #[serde(default)]
+    pub source_blocks: Vec<Value>,
+    #[serde(default)]
+    pub target_blocks: Vec<Value>,
+    #[serde(default)]
+    pub source_roles: Vec<Value>,
+    #[serde(default)]
+    pub target_roles: Vec<Value>,
+    #[serde(default)]
+    pub alignments: Vec<Value>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct TranslationSuggestion {
+    pub id: String,
+    pub label: String,
+    pub description: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub category: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub icon: Option<String>,
+    #[serde(default)]
+    pub steps: Vec<Value>,
+    #[serde(default, rename = "exclusiveWith")]
+    pub exclusive_with: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct TranslationSuggestionsResponse {
+    #[serde(default)]
+    pub suggestions: Vec<TranslationSuggestion>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct WordInsightVariation {
+    pub text: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub explanation: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct WordInsight {
+    pub id: String,
+    pub original_text: String,
+    pub r#type: String,
+    #[serde(default)]
+    pub variations: Vec<WordInsightVariation>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct WordInsightsResponse {
+    #[serde(default)]
+    pub insights: Vec<WordInsight>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub marked_translation: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct TranslateResponse {
+    pub bootstrap: TranslateBootstrapMetadata,
+    pub detected_language: TranslateDetectedLanguage,
+    pub translation: TranslateTextResponse,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub alternatives: Option<AlternativeTranslationsResponse>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub text_alignments: Option<TextAlignmentsResponse>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub translation_suggestions: Option<TranslationSuggestionsResponse>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub word_insights: Option<WordInsightsResponse>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub warnings: Vec<TranslateWarning>,
+}