Translating English to Russian with a neural network: model, prompt and checks

A neural network that translates text from English to Russian easily produces output that is understandable but sounds like a translation: calques, bureaucratic phrasing, inconsistent terms. The fix is not finding a magic model but three things: a clear style instruction, a glossary and an automatic check on the output. Below is a Python scheme, an example prompt and a price comparison of models on the same fragment. Prices are as of October 18, 2026.

What makes a translation natural

Typical flaws of machine translation into Russian:

• calques like "within the framework of this process" where "in this process" would do;
• verbal nouns and chains of genitives ("carrying out the conducting of an inspection");
• different translations of one term in different paragraphs;
• lost numbers, links and pieces of code;
• wrong address form: sometimes informal, sometimes formal.

Each of these is closed by an instruction or a check. So the prompt must describe the reader, the tone and the rules for terms, and not merely ask to "translate".

The translation prompt

A system message you can take as a base:

You translate technical and business texts from English into Russian.
The reader is a specialist who dislikes bureaucratic language. Address the reader formally.
Rules:
1. Translate meaning, not words. Avoid calques and noun chains.
2. Take terms strictly from the glossary. If a term is not in the glossary, keep
   the English version in parentheses on first mention.
3. Do not translate product names, commands, variable names, URLs or code.
4. Keep numbers, dates and links unchanged. Keep the Markdown markup.
5. Add nothing and skip nothing. Output only the translation.

Rule 5 matters: without it models like to add an introduction such as "Here is the translation".

A pipeline with a glossary and checks

Install the library: pip install openai. The code splits the text into fragments by paragraph, translates each one and checks the result:

import re
from openai import OpenAI

client = OpenAI(base_url="https://api.zukko.pro/v1", api_key="fetch_your_key")
MODEL = "claude-sonnet-5-5"

GLOSSARY = {
    "rate limit": "лимит запросов",
    "endpoint": "эндпоинт",
    "token": "токен",
    "fallback": "запасной вариант",
}

SYSTEM = """You translate technical and business texts from English into Russian.

Now the automatic check. It does not judge the beauty of the language, but it catches the most expensive errors: lost digits, links and terms:

def check(src, dst):
    problems = []
    if sorted(re.findall(r"\d+", src)) != sorted(re.findall(r"\d+", dst)):
        problems.append("numbers in the original and the translation differ")
    for url in re.findall(r"https?://\S+", src):
        if url.rstrip(".,)") not in dst:
            problems.append(f"link lost: {url}")
    for en, ru in GLOSSARY.items():
        stem = ru[:-2] if len(ru) > 6 else ru
        if en in src.lower() and stem not in dst.lower():
            problems.append(f"term '{en}' not translated per glossary")
    if len(dst) < 0.6 * len(src):
        problems.append("translation is suspiciously short: possible omissions")
    return problems

The glossary check is rough: Russian words inflect, so the comparison uses the stem without the last two letters. Treat it as a hint for a human, not a final verdict. The number comparison works on sorted lists of digit groups, so "1,000" in English versus "1 000" in Russian match and do not cause false alarms.

A second pass: editing

For texts going to publication, add a second call: give the model the original and the translation and ask it to find calques, omissions and inconsistent terms, returning a list of edits. Apply them after a human has looked. This pass almost doubles the cost, so do it only for important material.

Which model translates better

There is no universal answer to "which neural network is best for English to Russian translation", and there will be no quality comparisons here without measurements. Run your own test in half an hour: take three paragraphs with hard spots (idioms, terms, a joke, a list with code), translate them with different models, give the results blind to a native speaker and count how many edits were needed. The strength index in the catalog hints at the order of prices and capabilities, but it does not replace such a test.

For a price reference: suppose a fragment together with the instruction is 3000 input tokens, and the Russian translation is 6000 output tokens. These are assumptions: Russian text usually takes more tokens than English; more in the article on tokens and the Russian language↗. Calculation by the formula "input × input price + output × output price", prices as of October 18, 2026:

The gap between the most expensive and the cheapest model is huge, so a test on your own text pays off: a cheap model may be enough for internal documentation while marketing materials need a stronger one. Take current prices from GET https://api.zukko.pro/v1/models.

Practice for large volumes

• Split text by paragraph, not by character count, so sentences are not cut.
• Keep the glossary in a file and insert it into every request, or terms will drift between fragments.
• For long translation in one stream, see the article Translating texts through an API↗, and for localization files, translating i18n files↗.
• Request parameters are described in the Chat Completions reference↗.

The key for the pipeline is created in the dashboard↗; from Russia you can top up via SBP with the payment page's 8.5% fee, a MasterCard or cryptocurrency.

FAQ

Which neural network is best for English to Russian translation?

There is no single answer. Compare two or three models blind on your own text and take the price into account: the difference between models in the catalog reaches orders of magnitude.

How do I avoid calques and bureaucratic language in a translation?

Describe the reader and the tone, forbid bureaucratic phrasing directly in the instruction, set a glossary and, if needed, add a second editing pass.

Can I translate whole documents?

Yes, but it is better to split them into paragraph-based fragments and reassemble. This makes checking easier and reduces the risk of omissions. Models have a large context, but answer length is capped by the max_tokens parameter, and short pieces are easier to compare with the original.

How do I check that nothing was lost?

Automatically: compare numbers, links and text length, and check terms against the glossary. Selectively: have a native speaker review fragments.