---
title: "Comment traduire un fichier JSON dans une autre langue"
description: "Traduisez un fichier de langue JSON à l’aide d’un exemple fonctionnel, d’instructions pour les chaînes de votre application et d’une vérification Node.js des clés imbriquées, des valeurs et des espaces réservés."
date: 2026-10-20
language: fr
canonical: https://ai-glot.com/fr/blog/how-to-translate-json-files
source: AI Glot blog
---
**Pour traduire un fichier de langue JSON, importez le fichier source, indiquez la langue cible et traduisez les valeurs textuelles.** Commencez par un petit fichier dans le [traducteur JSON gratuit](/fr/file-formats/json-translation), puis vérifiez le fichier obtenu dans votre application. Vous pouvez [télécharger l’exemple](/examples/localization/en.json) utilisé ici.

Ce guide concerne les chaînes d’application, comme `locales/en.json`. Si votre fichier contient un catalogue de produits ou des enregistrements d’API, déterminez quels champs sont des textes lisibles avant d’appliquer la même méthode. Une valeur stockée sous forme de chaîne reste un identifiant si elle sert d’identifiant.

## Commencez par essayer ces six chaînes

L’exemple contient un écran de paiement et deux libellés de paramètres :

```json
{
  "checkout": {
    "title": "Your order",
    "greeting": "Hello, {{name}}",
    "pay": "Pay now",
    "support": "Contact Pinecart support"
  },
  "settings": {
    "language": "Language",
    "notifications": "Email notifications"
  }
}
```

Importez-le dans l’outil JSON et saisissez :

```text
Translate every text value into French.
Keep Pinecart in English and preserve {{name}} exactly.
```

L’outil gratuit accepte des fichiers allant jusqu’à **2 MB**, à raison de cinq par jour, et traduit jusqu’à **5 000 mots par fichier**. Les fichiers plus volumineux sont renvoyés complets, le texte restant étant inchangé. Le téléchargement peut donc servir d’exemple, mais ne constitue pas une version entièrement traduite. Utilisez [l’application](https://app.ai-glot.com/signup) pour traiter un fichier volumineux dans son intégralité, profiter d’un glossaire d’espace de travail et gérer des versions successives.

## Identifiez les éléments qui appartiennent à votre application

L’application fait appel à `checkout.title` ; l’utilisateur voit sa valeur. La variable de nom est renseignée à l’exécution. Ces deux éléments doivent être préservés lors d’un changement de langue.

*Illustration: Traduisez les valeurs, puis vérifiez les clés et les variables avant de valider un fichier de langue.*

AI Glot lit le JSON en tenant compte de sa structure et le réécrit avec une indentation de deux espaces. Un diff peut donc faire apparaître des changements d’espacement. Vérifiez les valeurs séparément de la mise en forme.

**Indiquez la convention utilisée pour les espaces réservés.** L’exemple suit la syntaxe d’i18next avec `{{name}}`. D’autres projets utilisent `{name}`, `%s` ou des messages ICU. Lorsque vous rédigez les consignes, copiez une chaîne réelle de votre application. Ne convertissez pas une convention en une autre pendant la traduction.

## Vérifiez le plan avant de lancer une tâche volumineuse

*Illustration: Une traduction JSON commence par un fichier source et s'achève par l'intégration d'un fichier de langue relu au sein de l'application.*

Pour les versions récurrentes, utilisez un [glossaire d’espace de travail](/fr/blog/build-translation-glossary-brand) pour les termes du produit et les noms des fonctionnalités. Les consignes de périmètre déterminent **quelles valeurs** sont traduites ; les règles de formulation déterminent **comment chaque valeur** est rédigée.

Un fichier source `en.json` seul ne permet pas de savoir quels libellés français ont été traduits le mois dernier. Demander de « traduire uniquement les chaînes françaises manquantes » ne fournit aucun fichier français de référence. Excluez les préfixes de clés connus, ou préparez ensemble les champs source et cible, puis vérifiez l’interprétation du plan. Le [guide des fichiers de langue d’application](/fr/blog/how-to-translate-app-language-files-with-ai) présente le processus général et d’autres formats.

## Effectuez une vérification structurelle avant de valider les modifications

Enregistrez le fichier téléchargé sous le nom `fr.json`, à côté de `en.json`. Copiez ce code dans `check-locale.mjs`, puis exécutez `node check-locale.mjs` avec Node.js. Le script vérifie les clés des objets imbriqués, la longueur des tableaux, les types de valeurs, les valeurs non textuelles inchangées et les espaces réservés à doubles accolades utilisés dans l’exemple.

```js

const source = JSON.parse(readFileSync('en.json', 'utf8'));
const target = JSON.parse(readFileSync('fr.json', 'utf8'));
const tokens = text => [...text.matchAll(/\{\{[^{}]+\}\}/g)]
  .map(match => match[0]).sort();

function check(a, b, path = '$') {
  assert.equal(typeof b, typeof a, `${path}: value type changed`);
  if (a === null || typeof a !== 'object') {
    if (typeof a === 'string') {
      assert.ok(b.trim().length || !a.trim().length,
        `${path}: translation is empty`);
      assert.deepEqual(tokens(b), tokens(a),
        `${path}: placeholders changed`);
    } else {
      assert.deepEqual(b, a, `${path}: non-text value changed`);
    }
    return;
  }
  assert.equal(Array.isArray(b), Array.isArray(a),
    `${path}: container type changed`);
  assert.ok(b !== null, `${path}: container is null`);
  if (Array.isArray(a)) {
    assert.equal(b.length, a.length, `${path}: array length changed`);
  }
  assert.deepEqual(Object.keys(b).sort(), Object.keys(a).sort(),
    `${path}: keys changed`);
  for (const key of Object.keys(a)) check(a[key], b[key], `${path}.${key}`);
}

check(source, target);
console.log('Keys, types and {{placeholders}} match. Review the wording next.');
```

**Cette vérification valide un contrat, pas la qualité de la traduction.** Une valeur laissée en anglais sera tout de même acceptée. Il en va de même pour une traduction grammaticalement incorrecte ou trop longue pour son bouton. La règle de jeton couvre `{{name}}`, mais pas tous les formats d’espaces réservés ; adaptez-la à la syntaxe de votre application.

Avec [i18next JSON v4](https://www.i18next.com/misc/json-format), les variantes de pluriel utilisent des suffixes propres à la langue, et vos appels fournissent un nombre. Préparez et testez les clés requises par votre langue cible. Cette vérification de l’égalité des clés rejette volontairement tout ensemble de clés modifié ; elle ne génère ni ne valide un nouvel inventaire de pluriels.

## Terminez dans l’application

Configurez le chargeur de langue française déjà utilisé par votre application pour qu’il pointe vers `fr.json`. Ouvrez le parcours de paiement, insérez un vrai nom et vérifiez le bouton le plus long sur l’écran le plus étroit pris en charge. Si vous utilisez des pluriels, testez les nombres qui déclenchent chaque forme dans la langue cible.

Pour un petit fichier, une relecture manuelle attentive peut suffire. Mais si vous devez traiter des milliers de chaînes à chaque version, regroupez le fichier source, le glossaire, cette vérification de structure et la revue de l’interface dans un même processus. La [solution de localisation d’applications](/fr/solutions/app-localization-file-translation) explique comment intégrer AI Glot lorsque plusieurs personnes participent à ce processus.