---
title: "Traduzir JSON de i18n para árabe com LLM: plurais | BroadRouter"
description: "Traduza arquivos JSON de i18n para árabe com uma API de LLM: congele placeholders, gere as seis formas de plural, valide o ICU na CI e isole os nomes inseridos."
url: https://broadrouter.com/pt/blog/translate-app-strings-to-arabic-llm/
lang: pt-BR
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traduzido do inglês com ajuda de IA. [Leia o original em inglês](https://broadrouter.com/blog/translate-app-strings-to-arabic-llm/) (atualizado em 2026-11-15).

# Traduzir strings de app para árabe com LLM: placeholders e plurais

Pela equipe da BroadNet Inference · 7 min de leitura · Publicado em 2026-11-15

Envie as strings como JSON com cada placeholder trocado por um marcador, peça as seis formas de plural do árabe (zero, one, two, few, many, other) e monte o plural ICU no código, não no modelo. Valide na CI: mesmas chaves, mesmos argumentos e tags, as seis formas presentes. Envolva os nomes inseridos em isolamentos Unicode para que o texto da direita para a esquerda seja exibido corretamente.

## Pontos principais

-   No CLDR, o árabe tem seis categorias de plural cardinal. Arquivos-fonte em inglês têm duas, então o modelo precisa escrever quatro formas que não existem na fonte.
-   Uma forma árabe faltando falha em silêncio. No nosso teste, uma mensagem ICU só com one e other exibiu "2 ملف" para 2 arquivos, em vez do dual ملفان, sem nenhum erro.
-   Troque placeholders e tags por marcadores como ⟦0⟧ antes da requisição e restaure-os depois. O modelo não consegue traduzir o que não vê.
-   Deixe o código montar a sintaxe de plural ICU a partir de seis strings simples. Depois faça o parse de cada mensagem com o parser do FormatJS na CI e quebre o build em qualquer lacuna.
-   Nomes interpolados e nomes de produto em letras latinas dentro do árabe precisam de isolamento bidi: bdi ou dir="auto" no HTML, U+2068 e U+2069 em texto puro.

**Nesta página**

1.  Por que os plurais do árabe quebram arquivos de strings traduzidos automaticamente?
2.  Como enviar as strings ao modelo?
3.  O script de tradução
4.  Como validar o arquivo em árabe na CI?
5.  E a exibição da direita para a esquerda?
6.  Quem deve revisar a saída?
7.  Quanto custa?
8.  Onde a BroadNet Inference entra

Traduzir os arquivos de strings de um app é um trabalho diferente de traduzir texto corrido. Cada valor é curto, muitas vezes sem contexto, e carrega sintaxe que o modelo não pode tocar: placeholders, tags HTML e regras de plural. Com o árabe, a última fica difícil. Arquivos em inglês têm duas formas de plural; o árabe precisa de seis. Este post monta um pequeno pipeline sobre um LLM compatível com a OpenAI: congela os placeholders, pede seis strings de plural simples, monta a sintaxe ICU no código e depois valida tudo na CI.

Para traduzir documentos, tickets e contratos, veja [tradução árabe–inglês com LLMs](https://broadrouter.com/pt/blog/arabic-english-translation-llm/), que cobre tom, glossários e avaliação para texto corrido.

## Por que os plurais do árabe quebram arquivos de strings traduzidos automaticamente?

O Unicode CLDR, que `Intl.PluralRules`, ICU e i18next seguem, dá ao árabe seis categorias cardinais:

| Categoria | Regra do CLDR | Números de exemplo | Exemplo: “arquivo” |
| --- | --- | --- | --- |
| zero | n = 0 | 0 | لا توجد ملفات |
| one | n = 1 | 1 | ملف واحد |
| two | n = 2 | 2 | ملفان (dual) |
| few | n % 100 = 3..10 | 3–10, 103–110 | 5 ملفات (plural) |
| many | n % 100 = 11..99 | 11–99, 111 | 11 ملفًا (singular, acusativo) |
| other | todo o resto | 100–102, 1000, 0,5 | 100 ملف (singular) |

Dois detalhes pegam as pessoas de surpresa. Primeiro, as categorias não são os números: 103 é few e 111 é many. Segundo, uma fonte em inglês dá ao modelo só `one` e `other`, então ele precisa inventar quatro formas apenas com a gramática. A maioria das falhas vem do modelo copiando o par do inglês.

A falha é silenciosa. Renderizamos com o intl-messageformat 12.1.5 uma mensagem em árabe que só tinha `one` e `other`: 0, 2 e 11 arquivos saíram todos como “N ملف”. O i18next 27.1.2 se comportou igual quando faltava a chave `_many`: 11 arquivos mostraram o texto de `_other`. Nenhum erro, nenhum aviso, só árabe errado.

## Como enviar as strings ao modelo?

Em lotes. Uma requisição por string gasta tokens com o system prompt e perde o contexto entre strings relacionadas. Envie de 50 a 200 chaves por vez como um objeto JSON, agrupadas por tela ou funcionalidade, para que “Save” ao lado de “Cancel” seja lido como botão.

Três regras tornam a resposta verificável:

1.  **Congele os placeholders.** Troque `{name}`, os placeholders de chave dupla do i18next, `%s`, `%1$s` e tags como `<b>` por marcadores como ⟦0⟧. O modelo vê “Welcome back, ⟦0⟧!” e não consegue traduzir `name` para اسم.
2.  **Peça as formas de plural como strings simples.** Envie os textos em inglês de `one` e `other` e peça seis strings em árabe. O código monta a sintaxe ICU. O modelo nunca escreve uma chave.
3.  **Forneça um glossário e uma lista do que não traduzir.** Nomes de produto, nomes de planos e termos que o seu time de suporte usa. A [seção de glossário do post sobre tradução](https://broadrouter.com/pt/blog/arabic-english-translation-llm/) explica por que isso importa mais que a escolha do modelo.

## O script de tradução

O arquivo-fonte usa ICU MessageFormat, a sintaxe documentada pelo FormatJS. O mesmo congelamento funciona com o formato JSON próprio do i18next, cujas chaves de plural terminam em `_zero`, `_one`, `_two`, `_few`, `_many` e `_other`.

```json
{
  "save": "Save",
  "welcome": "Welcome back, {name}!",
  "invite": "<b>{inviter}</b> invited you to the {workspace} workspace",
  "billing": "Pay with AcmePay",
  "files": "{count, plural, one {# file} other {# files}}"
}
```

```python
import json, os, re
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])

FORMS = ["zero", "one", "two", "few", "many", "other"]
# ICU arguments, double-brace and printf placeholders, HTML-style tags
PH = re.compile(r"\{\{\s*\w+\s*\}\}|\{\w+\}|%(?:\d+\$)?[sdif@]|</?\w+[^>]*>")
PLURAL = re.compile(r"^\{(\w+), plural,(.*)\}$", re.S)

def freeze(text):
    """Replace each placeholder with ⟦n⟧ so the model cannot translate or break it."""
    found = PH.findall(text)
    for i, p in enumerate(found):
        text = text.replace(p, f"⟦{i}⟧", 1)
    return text, found

def thaw(text, found):
    for i, p in enumerate(found):
        text = text.replace(f"⟦{i}⟧", p)
    return text

def branches(body):
    """'one {# file} other {# files}' -> {'one': '# file', 'other': '# files'}."""
    out, i = {}, 0
    while i < len(body):
        m = re.compile(r"\s*([=\w]+)\s*\{").match(body, i)
        if not m:
            break
        depth, j = 1, m.end()
        while depth:
            depth += {"{": 1, "}": -1}.get(body[j], 0)
            j += 1
        out[m.group(1)] = body[m.end():j - 1]
        i = j
    return out

SYSTEM = """You translate app interface strings from English to Modern Standard Arabic.
Reply with one JSON object only: {"STRINGS": {key: Arabic}, "PLURALS": {key: {six forms}}}.
Rules:
- ⟦0⟧, ⟦1⟧ ... are placeholders. Keep every one exactly once and unchanged; move it if Arabic word order needs it.
- # stands for the number. Keep it where the number should appear.
- Interface style: short, no full stops on buttons or labels.
- Never translate terms in DO_NOT_TRANSLATE. Use GLOSSARY translations exactly.
- For each PLURALS key, return all six Arabic forms: zero, one, two, few, many, other.
  zero = none; one = singular without a number; two = dual without a number;
  few = 3-10: # + plural noun; many = 11-99: # + singular noun in the accusative;
  other = 100, 1000 and also 0.5 and 1.5: # + singular noun."""

def translate(src, glossary=None, dnt=(), model="broadnet/qwen3.8-27b"):
    strings, plurals, frozen = {}, {}, {}
    for key, text in src.items():
        m = PLURAL.match(text)
        if m:
            b = branches(m.group(2))
            fone, ph = freeze(b.get("one", b["other"]))
            fother, _ = freeze(b["other"])
            plurals[key] = {"one": fone, "other": fother}
            frozen[key] = (m.group(1), ph)
        elif "{" in PH.sub("", text):
            raise ValueError(f"{key}: nested ICU, send to a human")
        else:
            strings[key], ph = freeze(text)
            frozen[key] = (None, ph)
    payload = {"STRINGS": strings, "PLURALS": plurals,
               "GLOSSARY": glossary or {}, "DO_NOT_TRANSLATE": list(dnt)}
    r = client.chat.completions.create(
        model=model, max_tokens=4000, temperature=0.2,
        messages=[{"role": "system", "content": SYSTEM},
                  {"role": "user", "content": json.dumps(payload, ensure_ascii=False)}])
    out = json.loads(r.choices[0].message.content)
    ar = {k: thaw(v, frozen[k][1]) for k, v in out.get("STRINGS", {}).items() if k in frozen}
    for k, forms in out.get("PLURALS", {}).items():
        if k not in frozen:
            continue
        arg, ph = frozen[k]
        ar[k] = "{%s, plural, %s}" % (arg, " ".join(
            f + " {" + thaw(forms[f], ph) + "}" for f in FORMS if f in forms))
    return ar

en = json.load(open("en.json"))
ar = translate(en, glossary={"workspace": "مساحة العمل"}, dnt=["AcmePay"])
json.dump(ar, open("ar.json", "w"), ensure_ascii=False, indent=2)
```

Rodamos isso com o SDK Python da OpenAI contra um servidor mock local, não contra a API real, com uma resposta em árabe pronta. A requisição que o modelo veria continha “Welcome back, ⟦0⟧!” e “⟦0⟧⟦1⟧⟦2⟧ invited you to the ⟦3⟧ workspace”, e o script gravou este `ar.json`:

```json
{
  "save": "حفظ",
  "welcome": "مرحبًا بعودتك يا {name}!",
  "invite": "دعاك <b>{inviter}</b> إلى مساحة العمل {workspace}",
  "billing": "ادفع عبر AcmePay",
  "files": "{count, plural, zero {لا توجد ملفات} one {ملف واحد} two {ملفان} few {# ملفات} many {# ملفًا} other {# ملف}}"
}
```

Observações sobre o código:

-   **Os marcadores mudam de lugar, não somem.** O árabe muitas vezes põe o verbo primeiro, então ⟦0⟧ pode se mover. A checagem abaixo conta os marcadores; não importa onde eles fiquem.
-   **ICU aninhado vai para uma pessoa.** Um `select` dentro de um `plural` é raro e fácil de quebrar. O script o recusa em vez de chutar.
-   **`max_tokens=4000` deixa espaço para o raciocínio.** A documentação da BroadNet diz que DeepSeek V4.1 Flash, GLM 5.3 e Qwen3.8 27B raciocinam antes de responder, e que o raciocínio conta para [max\_tokens](https://broadrouter.com/pt/glossary/max-tokens/). Veja [respostas vazias de modelos de raciocínio](https://broadrouter.com/pt/guides/reasoning-tokens-empty-response/).
-   **`json.loads` pode falhar.** Envolva a chamada e reenvie uma vez com o erro; [como corrigir JSON inválido de um LLM](https://broadrouter.com/pt/blog/fix-invalid-json-from-llm/) tem uma função de reparo testada. No GLM 5.3 e no Qwen3.8 27B, os dois modelos da BroadNet documentados com [saída estruturada](https://broadrouter.com/pt/glossary/structured-output/), acrescente também um schema em `response_format`. A checagem abaixo continua valendo de qualquer forma.

## Como validar o arquivo em árabe na CI?

Faça o parse de cada mensagem com o mesmo parser que o seu app usa em tempo de execução e compare com a fonte. Este script Node usa o `@formatjs/icu-messageformat-parser` (versão 3.5.23 no nosso teste):

```js
// node check-ar.mjs en.json ar.json  -> exits 1 on any problem
import { readFileSync } from "node:fs";
import { parse, TYPE } from "@formatjs/icu-messageformat-parser";

const AR_FORMS = ["zero", "one", "two", "few", "many", "other"];
const [en, ar] = process.argv.slice(2).map((p) => JSON.parse(readFileSync(p, "utf8")));
const errors = [];

// Collect argument and tag names; return the plural elements too.
function walk(nodes, names = [], plurals = []) {
  for (const n of nodes) {
    if (n.type === TYPE.literal || n.type === TYPE.pound) continue;
    names.push(n.type === TYPE.tag ? `<${n.value}>` : `{${n.value}}`);
    if (n.type === TYPE.tag) walk(n.children, names, plurals);
    if (n.type === TYPE.plural) plurals.push(n);
    if (n.options) for (const o of Object.values(n.options)) walk(o.value, [], plurals);
  }
  return { names: names.sort().join(" "), plurals };
}

for (const key of Object.keys(en)) {
  if (!(key in ar)) { errors.push(`${key}: missing`); continue; }
  let src, dst;
  try { src = walk(parse(en[key])); dst = walk(parse(ar[key], { requiresOtherClause: true })); }
  catch (e) { errors.push(`${key}: ICU syntax error ${e.message}`); continue; }
  if (src.names !== dst.names) errors.push(`${key}: arguments differ: [${src.names}] vs [${dst.names}]`);
  for (const p of dst.plurals) {
    const missing = AR_FORMS.filter((f) => !(f in p.options));
    if (missing.length) errors.push(`${key}: plural {${p.value}} lacks ${missing.join(", ")}`);
  }
  if (!/[؀-ۿ]/.test(ar[key])) errors.push(`${key}: no Arabic letters`);
  if (/⟦\d+⟧/.test(ar[key])) errors.push(`${key}: placeholder marker left in text`);
}
for (const key of Object.keys(ar)) if (!(key in en)) errors.push(`${key}: not in source`);
console.log(errors.join("\n") || "ok");
process.exit(errors.length ? 1 : 0);
```

No arquivo acima, ele imprimiu `ok`. Depois fizemos a resposta do mock perder a forma `many` e o marcador `{workspace}`. O script saiu com código 1 e imprimiu:

```text
invite: arguments differ: [<b> {inviter} {workspace}] vs [<b> {inviter}]
files: plural {count} lacks many
```

A regra “no Arabic letters” aponta strings que o modelo deixou em inglês. Ela também aponta valores que são só um nome de produto ou um número, então mantenha uma allow-list para esses casos. Para o formato próprio do i18next, aplique as mesmas checagens chave por chave: cada par `_one`/`_other` em inglês exige em árabe as seis chaves com sufixo, cada uma com os mesmos placeholders, exceto que `_zero`, `_one` e `_two` podem omitir a contagem.

Por fim, passe alguns números pelo seu formatador real. Com o intl-messageformat 12.1.5, a mensagem `files` acima deu 0 → لا توجد ملفات, 2 → ملفان, 5 → 5 ملفات, 11 → 11 ملفًا, 102 → 102 ملف e 111 → 111 ملفًا. Essa checagem por amostragem pega uma forma que passa no parser mas usa o substantivo errado.

## E a exibição da direita para a esquerda?

A tradução acerta as palavras; o navegador ainda precisa ordená-las. Quando um nome em letras latinas ou um número é inserido numa frase em árabe, o algoritmo bidirecional do Unicode pode mover a pontuação ou trocar trechos vizinhos de lugar. A recomendação do W3C é isolar o texto inserido: envolvê-lo em `<bdi>` ou num elemento com `dir="auto"` no HTML, ou cercá-lo com U+2068 FIRST STRONG ISOLATE e U+2069 POP DIRECTIONAL ISOLATE em texto puro, como em notificações push.

Faça isso onde você interpola, não na tradução. No nosso teste, formatar a mensagem de boas-vindas com o nome entre U+2068 e U+2069 manteve os dois caracteres na saída e deixou o árabe intacto. Defina também `dir="rtl"` e `lang="ar"` na página ou no contêiner. [Engenharia de prompt em árabe](https://broadrouter.com/pt/blog/arabic-prompt-engineering/) tem um checklist curto para bugs de exibição RTL.

Dígitos são escolha do formatador, não da tradução. Mantenha `#` ou o argumento na string. No Node 24 (ICU 78.3), o `Intl.NumberFormat` escreveu 1234 como 1,234 para `ar` e como ١٬٢٣٤ para `ar-EG` e `ar-SA`. Escolha a tag de locale que corresponde ao seu mercado. Para as questões de produto mais amplas (idioma da interface versus idioma do modelo, balões de chat com direções misturadas, detecção de idioma e custo por idioma), veja [como projetar uma experiência de IA em vários idiomas](https://broadrouter.com/pt/blog/multilingual-product-design/).

## Quem deve revisar a saída?

Um pipeline de LLM com essas checagens garante que o arquivo está bem formado. Não garante que o árabe está certo. Peça a um falante de árabe para revisar:

-   **Só as strings novas e alteradas.** Faça o diff do `en.json` contra o último lançamento e traduza só o que mudou. As revisões ficam pequenas, e as strings aprovadas não mudam mais.
-   **As formas de plural, palavra por palavra.** A concordância com números é onde o modelo mais escorrega, principalmente o acusativo depois de 11 a 99.
-   **O gênero.** Em árabe, “você” e os verbos mudam com o gênero de quem lê. Se a sua interface fala diretamente com o usuário, defina uma convenção, como uma forma fixa ou uma reformulação neutra, e coloque-a no system prompt.
-   **O comprimento.** Strings em árabe podem ficar mais longas ou mais curtas que em inglês. Confira botões e abas no layout real, na largura de celular.

Mantenha no repositório um arquivo de glossário revisado e envie-o em toda requisição, para que os termos aprovados fiquem fixos.

## Quanto custa?

Arquivos de strings são pequenos. A saída tem mais ou menos o tamanho da entrada, e o árabe costuma precisar de mais tokens por palavra que o inglês; [tokens por palavra em árabe e inglês](https://broadrouter.com/pt/blog/tokens-per-word-arabic-english/) traz proporções medidas. Cole um lote no [contador de tokens para árabe](https://broadrouter.com/tools/arabic-token-counter/), multiplique pelo número de lotes e some o system prompt a cada um. Modelos de raciocínio também gastam tokens pensando; a BroadNet os informa em `usage` como `completion_tokens_details.reasoning_tokens`, então leia o `usage` de uma requisição real antes de extrapolar.

| Modelo | Observações para este trabalho | Entrada / saída por 1M de tokens |
| --- | --- | --- |
| [Qwen3.8 27B](https://broadrouter.com/pt/models/qwen3.8-27b/) | Saída estruturada documentada | $0.175 / $2.17 |
| [GLM 5.3](https://broadrouter.com/pt/models/glm-5.3/) | Saída estruturada documentada; contexto de 1.048.576 tokens | $0.78 / $3.46 |
| [Gemma 4 VL 26B](https://broadrouter.com/pt/models/gemma-4-vl-26b/) | Roda com o crédito inicial de $5; JSON só via prompt, então o validador pesa mais | $0.10 / $0.22 |
| [DeepSeek V4.1 Flash](https://broadrouter.com/pt/models/deepseek-v4.1-flash/) | Também em planos de preço fixo, como $15 por semana por sessão, uma requisição por vez por sessão | $0.175 / $0.52 |

Os preços vêm do feed de preços da BroadNet, sincronizados 2026-11-14. Traduza as mesmas 100 strings com dois modelos e peça ao seu revisor para compará-las antes de escolher; o preço por token importa menos que o número de correções. Para milhares de chaves em muitos idiomas, [processamento em lote sem uma Batch API](https://broadrouter.com/pt/blog/llm-batch-processing-without-batch-api/) cobre concorrência e novas tentativas.

## Onde a BroadNet Inference entra

O BroadRouter é o site da própria BroadNet. A BroadNet Inference dá acesso compatível com a OpenAI aos modelos acima, então o script roda com o [SDK Python da OpenAI](https://broadrouter.com/pt/guides/openai-python-sdk/) depois de trocar a base URL e o ID do modelo; confira na [referência da API](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-translate-app-strings-to-arabic-llm&utm_content=body) os parâmetros que cada modelo aceita. Ela não tem endpoint de tradução e não publica benchmark de localização, então o validador e um revisor humano continuam sendo o seu controle de qualidade. Plataformas dedicadas de localização acrescentam memória de tradução, fluxos de revisão e capturas de tela em contexto; se você precisa disso, use uma e mantenha a checagem de CI acima como segunda linha.

Ferramentas gratuitas sobre o tema (em inglês)

-   [Arabic token counter](https://broadrouter.com/tools/arabic-token-counter/) Arabic vs English token counts per tokenizer: the "Arabic tax" in tokens and money.
-   [Arabic text normalizer](https://broadrouter.com/tools/arabic-text-normalizer/) Tashkeel, tatweel, alef, ya, ta marbuta, digits and invisible characters, with a matching Python function.
-   [Speech-to-text cost calculator](https://broadrouter.com/tools/speech-to-text-cost-calculator/) Hours, calls or voice notes to a monthly transcription bill, against your current provider.

[Ferramentas gratuitas (em inglês)](https://broadrouter.com/tools/)

## Termos neste artigo

[Token](https://broadrouter.com/pt/glossary/token/)

Um token é a unidade de texto que um modelo de linguagem lê e escreve: uma palavra, parte de uma palavra, um sinal de pontuação ou uma sequência de bytes gerada pelo tokenizador do modelo. As APIs de LLM contam, limitam e normalmente cobram o uso em tokens.

[Prompt de sistema (system prompt)](https://broadrouter.com/pt/glossary/system-prompt/)

O system prompt, ou prompt de sistema, é o texto de instruções que uma aplicação envia a um modelo de linguagem antes da conversa, em geral como mensagem com o papel system ou developer. Ele define o papel, as regras, o tom e o formato de saída do modelo, que deve segui-lo mesmo quando mensagens do usuário o contradizem.

[Saída estruturada (structured output)](https://broadrouter.com/pt/glossary/structured-output/)

Saída estruturada é um recurso de APIs de LLM que restringe a resposta de um modelo a um formato definido pelo desenvolvedor, normalmente um JSON Schema, para que o código consiga interpretá-la de forma confiável. É mais rigorosa que o JSON mode, que garante um JSON válido, mas não uma estrutura específica.

[Base URL (URL base)](https://broadrouter.com/pt/glossary/base-url/)

A base URL é o endereço raiz fixo de uma API, como https://api.example.com/v1, que um cliente coloca antes de cada caminho de endpoint, como /chat/completions. Nos SDKs compatíveis com a OpenAI, trocar a base URL, junto com a chave de API e o ID do modelo, aponta o mesmo código para outro provedor.

[Batch API (API de lote)](https://broadrouter.com/pt/glossary/batch-api/)

Batch API é um endpoint assíncrono de LLM que aceita muitas requisições de uma vez, normalmente em um arquivo, processa tudo dentro de uma janela definida em vez de na hora e devolve os resultados juntos. Provedores como OpenAI e Anthropic cobram as requisições em lote com desconto em relação às APIs padrão.

[Concorrência (concurrency)](https://broadrouter.com/pt/glossary/concurrency/)

Concorrência é o número de requisições que um cliente tem em andamento ao mesmo tempo. APIs de LLM muitas vezes a limitam por chave ou por plano, separadamente das requisições por minuto, porque cada requisição aberta ocupa capacidade de GPU até a resposta terminar.

[Engenharia de prompt (prompt engineering)](https://broadrouter.com/pt/glossary/prompt-engineering/)

Engenharia de prompt é o processo de escrever, estruturar e testar as instruções dadas a um modelo de linguagem para que ele produza, de forma consistente, uma saída que atenda aos seus requisitos. Inclui mensagens de papel, instruções claras, exemplos, formatação e a medição dos resultados com casos de teste.

[max\_tokens](https://broadrouter.com/pt/glossary/max-tokens/)

max\_tokens é um parâmetro de APIs de LLM que define o máximo de tokens que um modelo pode gerar em uma resposta. Quando a geração atinge o limite, ela para e a resposta é marcada como cortada, por exemplo com finish\_reason igual a "length".

## Perguntas frequentes

### Quantas formas de plural o árabe tem?

Seis categorias cardinais no Unicode CLDR: zero (0), one (1), two (2), few (números que terminam de 03 a 10, como 3 a 10 e 103), many (que terminam de 11 a 99) e other (100 a 102, 1000 e decimais como 0,5). Um arquivo em inglês só tem one e other.

### O ChatGPT ou outro LLM consegue traduzir meu arquivo JSON de i18n para árabe?

Sim, se você controlar o formato. Envie só os valores, troque os placeholders por marcadores, peça seis formas de plural e confira o resultado no código: chaves, argumentos, tags e categorias de plural. Peça a um falante de árabe para revisar as strings novas antes do lançamento.

### O que acontece se faltar uma forma de plural na tradução para árabe?

Normalmente nada quebra de forma visível. O i18next e o intl-messageformat caem na forma other, então 2 arquivos aparecem como "2 ملف" em vez do dual ملفان. Só um validador que exige as seis formas pega isso antes dos usuários.

### O LLM deve escrever a sintaxe ICU MessageFormat sozinho?

Melhor não. Peça seis strings simples por mensagem de plural e monte a sintaxe ICU no código. De vez em quando os modelos perdem uma chave ou traduzem o nome do argumento, e aí um erro de parser derruba o bundle inteiro em tempo de execução.

### Quais dígitos as strings de interface em árabe devem usar?

Deixe o formatador de números decidir, não a tradução. Mantenha # ou o argumento na string. No nosso teste com Node 24, o Intl.NumberFormat formatou 1234 como 1,234 para ar e como ١٬٢٣٤ para ar-EG e ar-SA, ou seja, a tag de locale define os dígitos.

## Continue lendo

-   [Tradução árabe–inglês com LLMs: prompts, glossários e avaliação](https://broadrouter.com/pt/blog/arabic-english-translation-llm/)
-   [Engenharia de prompt em árabe: registro, RTL, números e texto misto](https://broadrouter.com/pt/blog/arabic-prompt-engineering/)
-   [JSON mode vs json\_schema: saída estruturada que não quebra](https://broadrouter.com/pt/blog/structured-output-json-schema/)
-   [Como corrigir JSON inválido de um LLM: causas, reparo e retry](https://broadrouter.com/pt/blog/fix-invalid-json-from-llm/)
-   [Tokens por palavra em árabe vs inglês: por que o árabe custa mais](https://broadrouter.com/pt/blog/tokens-per-word-arabic-english/)
-   [Processamento em lote com LLM sem Batch API: um runner retomável](https://broadrouter.com/pt/blog/llm-batch-processing-without-batch-api/)
-   [Como projetar uma experiência de IA em vários idiomas](https://broadrouter.com/pt/blog/multilingual-product-design/)
-   [Diacríticos no árabe com um LLM: prompt, checagens e DER](https://broadrouter.com/pt/blog/arabic-diacritization-llm/)
-   [Correção gramatical e ortográfica do árabe com um LLM: passo a passo](https://broadrouter.com/pt/blog/arabic-grammar-spelling-correction-llm/)
-   [Guia: Como usar o SDK Python da OpenAI com a BroadNet Inference](https://broadrouter.com/pt/guides/openai-python-sdk/)
-   [Guia: Por que um modelo de raciocínio devolve uma resposta vazia](https://broadrouter.com/pt/guides/reasoning-tokens-empty-response/)

Teste com a sua carga de trabalho real. Contas novas começam com US$ 5 de crédito para Gemma e transcrição. DeepSeek, GLM e Qwen3.8 exigem uma recarga.

[Começar](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-translate-app-strings-to-arabic-llm&utm_content=page-cta) ·

**Fontes**

-   [Unicode CLDR, tabela Language Plural Rules: categorias cardinais do árabe zero, one, two, few (n % 100 = 3..10), many (n % 100 = 11..99), other (consultado em 2026-11-15)](https://www.unicode.org/cldr/charts/latest/supplemental/language_plural_rules.html)
-   [MDN, Intl.PluralRules.prototype.select(): o árabe tem 6 formas para números cardinais (consultado em 2026-11-15)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/PluralRules/select)
-   [FormatJS, sintaxe de mensagens: categorias de plural, correspondências exatas =valor, o símbolo #, other obrigatório, escape com apóstrofo (consultado em 2026-11-15)](https://formatjs.github.io/docs/core-concepts/icu-syntax)
-   [Documentação do i18next, Plurals: sufixos \_zero, \_one, \_two, \_few, \_many, \_other, exemplo em árabe, Intl.PluralRules, variável count (consultado em 2026-11-15)](https://www.i18next.com/translation-function/plurals)
-   [Documentação do i18next, formato JSON: chaves de plural v4 e interpolação (consultado em 2026-11-15)](https://www.i18next.com/misc/json-format)
-   [W3C Internationalization, marcação inline e texto bidirecional em HTML: dir, bdi, FSI U+2068 e PDI U+2069 (consultado em 2026-11-15)](https://www.w3.org/International/articles/inline-bidi-markup/)
-   [Referência da API da BroadNet Inference: IDs de modelo, saída estruturada para GLM 5.3 e Qwen3.8 27B, o raciocínio conta para max\_tokens (consultado em 2026-11-15) (em inglês)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-translate-app-strings-to-arabic-llm&utm_content=sources)
