Video game localization costs: build the estimate from your own text

この記事を日本語で読む

Process & operations ·

If you are about to put your first game into English or Japanese, the question you want answered is a number. No article can honestly give you one. The price depends on how much text the game has, what kind of text it is, the language pair, and rates that differ from one translator to the next and change over time. What you can do, before contacting anyone, is build the estimate yourself, so that a quote you receive is something you can check rather than something you simply accept.

This article walks through that build. It splits the cost into the part that grows with your text and the part that does not, counts one small sample string table several ways to show how far the same file can move (from 52 to 71 English words, and from 132 to 212 Japanese characters), gives you a script to run the same count on your own export, and ends with what to send and what to ask when you request a quote. Every count here came from a command run on that sample table. The per-word rate stays a blank for you to fill in from real quotes.

Two kinds of cost: what scales with your text and what does not

A localization budget has one part that is roughly a quantity of text multiplied by a rate, and another part driven by how your game is built and shipped. An estimate built only from a word count shows the first part and none of the second, so the second has to be listed on purpose.

  • Translation. Priced against a quantity of source text, per word or per character. The unit, and how repeats and placeholders are counted, decide the quantity; the next section shows how much that can matter.
  • A second-pass review by another linguist, if you buy one. Providers price it in different units, so ask what it is measured in and whether it is inside the translation rate or a separate line.
  • Engineering on your side. Moving hardcoded text out of code into a string table, adding a language switch, swapping in a font that contains the target script, and fixing screens where the new text no longer fits. This is your time or a programmer's time, not a per-word line.
  • Testing the translated build, often called LQA (linguistic quality assurance): someone plays the localized game and reports cut-off text, lines that are wrong in context, and broken variables. It is measured in hours of play, not words, so a game with little text but a long playthrough costs more to test than its word count suggests.
  • Text inside images. A title logo, a painted sign, a label baked into a sprite. In the sample below the logo is three words; the work is redrawing and re-exporting the image, which no per-word rate covers.
  • Store page and marketing text. Short and long descriptions, capsule art text, trailer subtitles. Small in volume, and in a schedule it may be needed earlier than the game text, for example when the store page goes up before release.
  • Changes after the quote. Strings added or edited after you sent the file. Agree in advance how they will be counted and billed.
  • Overheads such as a minimum charge, rush fees, or handling for an unusual file format. Whether any of these apply is something only the provider's quote can tell you.

Count your text the way a quote will, not the way an editor does

To see what counting rules do to the quantity, I built a 15-row string table that looks like a small game's export: menu labels, system messages with placeholders, three lines of dialogue, a title logo, and a one-line store blurb. Each row has an English source and a Japanese translation, so it works for either direction. The counts below were produced in Node and checked against a separate Python implementation; both printed the same numbers.

Placeholders and markup come first. A naive whitespace split treats {item}, %d and colour tags as words. Slot %d - %s is four tokens to that split and one English word to a translator. Removing placeholders and tags took the English count from 71 to 64 without touching a single word anyone translates.

Repeats come next. Cancel appears twice, under the keys common.cancel and shop.cancel, and a guard repeats the village elder's line about the bridge word for word. That is 2 of 15 rows and 12 words. Whether a repeat is charged in full, at a reduced rate, or not at all is a pricing decision by whoever quotes, and in this table it moves the quantity anywhere between 52 and 64 words.

Japanese makes the effect larger. It does not put spaces between words, so a word count does not work for Japanese source text and the unit becomes characters. Markup weighs far more in that unit: in the row that announces a found item, the colour tag and the item placeholder add up to 28 characters around 7 characters of Japanese text. Counted raw, the Japanese column is 212 characters; without markup it is 157; without markup or repeats it is 132.

  • The spread is the range of quantity you could be quoted for an identical file before any rate is applied. Two quotes with the same per-word rate can still differ by that much.
  • Translation tools count by their own rules. A CAT tool (computer-assisted translation software) splits text into segments and reports exact repeats and near matches separately, so its number will not match a plain word count. What a CAT tool is explains what those reports contain.
  • Story-heavy games need a counting plan of their own, because branches, names and repeated narration change what counts as one line. Counting words in a visual novel and planning its translation covers that case.
  • Image text is three words in the sample and the hardest row to price by word. Keep a separate list of every image that contains text.
Same 15-row table, counted four ways

English source (words)
  split on spaces                       71
  placeholders and tags removed         64
  ...and exact repeats removed          52
  repeated rows: 2 of 15, 12 words

Japanese source (characters, spaces excluded)
  raw                                  212
  placeholders and tags removed        157
  ...and exact repeats removed         132

Spread between the largest and smallest count
  English   71 / 52  = 1.365
  Japanese 212 / 132 = 1.606

Cleaned English words by kind of text
  dialogue 34   store 12   ui 9   system 6   image 3

Run the same count on your own string export

Export your string table as CSV with a header row, then run the script below with the name of the source-language column. It reads quoted fields correctly, including commas and doubled quotation marks inside a line, skips empty cells, and prints totals with and without exact repeats in both words and characters. Use the word figures for an English source and the character figures for a Japanese one. The column name must match the header exactly; a misspelled name finds no column and every count except rows comes out as 0. Before trusting the output, edit the TAG pattern to match your engine's placeholder syntax; the one shown handles curly-brace names, %d and %s, and angle-bracket tags only.

  • The 4-row test file at the end of the code block contains a quoted comma, doubled quotes and one duplicated dialogue line; run against it, the script printed 29 words and 17 fresh words for the English column, and 80 characters and 48 fresh characters for the Japanese one. Rerun it to confirm your copy works before using it on your own export.
  • It only treats identical text as a repeat. Lines that differ by a word are not caught; translation tools report those as near matches and may price them differently, which is another question for the quote.
  • If earlier translations of your game exist, keep them in a reusable form. A translation memory file lets a translator's tool recognise text that was already done; TMX and TBX explained covers the file formats.
  • Keys, comment columns and developer notes are not counted. Send them anyway: they are context, not quantity.
// count.js  usage: node count.js strings.csv <source column name>
const fs = require("fs");
const [file, col] = process.argv.slice(2);
const text = fs.readFileSync(file, "utf8").replace(/^\uFEFF/, "");
const rows = []; let row = [], f = "", q = false;
for (let i = 0; i < text.length; i++) {
  const c = text[i];
  if (q) { if (c === '"' && text[i + 1] === '"') { f += '"'; i++; } else if (c === '"') q = false; else f += c; }
  else if (c === '"') q = true;
  else if (c === ",") { row.push(f); f = ""; }
  else if (c === "\n") { row.push(f.replace(/\r$/, "")); rows.push(row); row = []; f = ""; }
  else f += c;
}
if (f || row.length) { row.push(f); rows.push(row); }
const head = rows.shift(), k = head.indexOf(col);
// Edit TAG to match your engine's placeholder and markup syntax.
const TAG = /<[^>]+>|\{[^}]+\}|%[ds]/g;
const clean = (s) => s.replace(TAG, " ");
const words = (s) => clean(s).split(/\s+/).filter((w) => /[\p{L}\p{N}]/u.test(w)).length;
const chars = (s) => [...clean(s).replace(/\s/g, "")].length;
const seen = new Set(); let total = 0, fresh = 0, totalC = 0, freshC = 0;
for (const r of rows) {
  const s = (r[k] ?? "").trim(); if (!s) continue;
  total += words(s); totalC += chars(s);
  if (!seen.has(s)) { seen.add(s); fresh += words(s); freshC += chars(s); }
}
console.log({ rows: rows.length, unique: seen.size, words: total, freshWords: fresh, chars: totalC, freshChars: freshC });

# sample.csv (4-row test file)
key,type,en,ja
shop.confirm,ui,"Buy {item} for {price} gold?",{item}を{price}ゴールドで買いますか?
dlg.a,dialogue,"If you can find the ferryman, he may still take you across.",渡し守を見つけられれば、まだ向こう岸へ渡してもらえるかもしれん。
dlg.b,dialogue,"If you can find the ferryman, he may still take you across.",渡し守を見つけられれば、まだ向こう岸へ渡してもらえるかもしれん。
q,ui,"Say ""hi""",「やあ」

$ node count.js sample.csv en
{ rows: 4, unique: 3, words: 29, freshWords: 17, chars: 114, freshChars: 66 }
$ node count.js sample.csv ja
{ rows: 4, unique: 3, words: 5, freshWords: 4, chars: 80, freshChars: 48 }

Still checking translation files by eye?

Loclint scans your CSV/JSON localization files and flags broken placeholders, untranslated strings, and encoding risks in seconds.

Run your first check — freeFree for 500 strings checked a month · no credit card

Turn the count into a formula and leave the rate blank

With a quantity in hand, the estimate is one formula with a few named blanks. R is the per-word (or per-character) translation rate. m is the share of R charged for repeated text, between 0 and 1. R2 is a review rate if review is listed separately. H is an hourly rate for the work that does not scale with text. All of them come from quotes, not from articles, which is why none has a value here.

  • Compare quotes by applying each one to your own counted file, not by comparing rates side by side. A lower rate under a looser counting rule can produce the larger total.
  • Write every fixed line down by name, with its own figure in hours or as a quoted fee. A single percentage added on top hides which part is actually expensive.
  • Leave an explicit line for changes after the quote. If text is still being written when you ask for a quote, plan on it growing, because the formula only covers what you sent.
  • If you want to see how a candidate rate behaves, multiply it through yourself: if R were some value X, the sample costs between 52X and 64X for translation alone. Treat the result as a sanity check on a quote, never as a substitute for one.
Translation  = fresh_words x R  +  repeated_words x R x m
Review       = (fresh_words + repeated_words) x R2      (if listed separately)
Fixed lines  = engineering_hours x H
             + testing_hours x H_test
             + each image with text (quoted per asset)
             + store page text (quoted separately or counted with the rest)
Total        = Translation + Review + Fixed lines + changes after the quote

The sample table, English source:
  52 x R  +  12 x R x m       ->  between 52R (m = 0) and 64R (m = 1)
  the same file counted raw   ->  71R

What to send with a quote request, and what to ask back

A quote is only as accurate as what it was based on. The more of the list below you send, the less the provider has to guess about scope. Most of it is the same material a translator needs to do the work; preparing a localization kit describes that package in detail.

  • Send: the string export with keys, and the counts you made yourself, both total and with repeats removed, so any difference in the quote's numbers is visible immediately.
  • Send: context for each kind of text, such as screenshots, who is speaking, and character limits for buttons and other tight UI spots.
  • Send: a list of placeholders and tags with what each one becomes at runtime, so nobody translates a variable name.
  • Send: the list of images that contain text, the store page text, target languages and regional variants, the date you need delivery, and whether the text is final.
  • Ask: which unit the quote uses, words or characters, and whether it counts the source or the translation.
  • Ask: how repeats, near matches and placeholders are counted, and at what share of the rate.
  • Ask: whether review by a second linguist is included, whether there is a minimum charge, and how later additions will be billed.
  • Ask: whether testing in the build is included and in what form. What localization QA (LQA) is explains what that testing involves and what it catches.
  • Ask: what format the translation comes back in and who holds the rights to it. For contract terms such as rights and liability, check with a professional before signing.

Ship your next update with every string checked

Upload a CSV/JSON file and Loclint checks every entry — placeholders, untranslated text, duplicate keys, length limits — and tracks regressions between runs.

Related articles