# gt-next: General Translation Next.js SDK: Démarrage rapide Next.js
URL: https://generaltranslation.com/fr/docs/next.mdx
---
title: Démarrage rapide Next.js
description: Ajoutez plusieurs langues à votre application Next.js en moins de 10 minutes
---
À la fin de ce guide, votre application Next.js affichera du contenu en plusieurs langues, avec un sélecteur de langue que vos utilisateurs pourront utiliser.
**Prérequis :**
* Une application Next.js utilisant l’**App Router** (Next.js 13+)
* Node.js 18+
**Vous préférez une configuration automatique ?** Exécutez `npx gt@latest` pour tout configurer avec l’[assistant de configuration](/docs/cli/init). Ce guide présente la configuration manuelle.
***
## Étape 1 : Installez les packages
`gt-next` est la bibliothèque qui prend en charge les traductions dans votre application. `gt` est l’outil en ligne de commande qui prépare les traductions pour la production.
```bash
npm i gt-next
npm i -D gt
```
```bash
yarn add gt-next
yarn add --dev gt
```
```bash
bun add gt-next
bun add --dev gt
```
```bash
pnpm add gt-next
pnpm add --save-dev gt
```
***
## Étape 2 : Configurez votre configuration Next.js
`gt-next` utilise un plugin Next.js appelé **`withGTConfig`** pour configurer l’internationalisation au moment du build. Entourez votre configuration Next.js existante avec celui-ci :
```ts title="next.config.ts"
import { withGTConfig } from 'gt-next/config';
const nextConfig = {};
export default withGTConfig(nextConfig);
```
Ce plugin lit vos paramètres de traduction et s’occupe de tout en coulisses. Aucune autre modification de votre configuration Next.js n’est nécessaire.
***
## Étape 3 : Créez un fichier de configuration de traduction
Créez un fichier **`gt.config.json`** à la racine de votre projet. Il indique à la bibliothèque les langues que vous prenez en charge :
```json title="gt.config.json"
{
"defaultLocale": "en",
"locales": ["es", "fr", "ja"],
"files": {
"gt": {
"output": "public/_gt/[locale].json"
}
}
}
```
* **`defaultLocale`** — la langue dans laquelle votre application est écrite (votre langue source).
* **`locales`** — les langues vers lesquelles vous souhaitez traduire. Choisissez celles que vous voulez dans la [liste des paramètres régionaux pris en charge](/docs/platform/supported-locales).
* **`files.gt.output`** — l’emplacement où la CLI enregistre les fichiers de traduction. `[locale]` est remplacé par chaque code de langue (par ex. `public/_gt/es.json`).
Ajoutez `public/_gt/` à votre **`.gitignore`** — ces fichiers sont générés, et non écrits à la main :
```txt title=".gitignore"
public/_gt/
```
***
## Étape 4 : Ajoutez GTProvider à votre layout
Le composant **`GTProvider`** permet à l’ensemble de votre application d’accéder aux traductions. Il doit envelopper votre application au niveau du layout racine :
```tsx title="app/layout.tsx"
import { GTProvider } from 'gt-next';
export default function RootLayout({ children }: { children: React.ReactNode }) {
return (
{children}
);
}
```
`GTProvider` est un **composant serveur** : il charge les traductions côté serveur et les transmet à vos composants clients.
***
## Étape 5 : Marquez le contenu à traduire
Maintenant, entourez du composant **``** tout texte que vous souhaitez traduire. `` signifie "translate" :
```tsx title="app/page.tsx"
import { T } from 'gt-next';
export default function Home() {
return (
Welcome to my app
This content will be translated automatically.
);
}
```
Vous pouvez inclure autant ou aussi peu de JSX que vous le souhaitez dans ``. Tout ce qui s’y trouve — le texte, les éléments imbriqués, même la mise en forme — est traduit comme un seul bloc.
***
## Étape 6 : Ajouter un sélecteur de langue
Ajoutez un **``** pour que les utilisateurs puissent changer de langue :
```tsx title="app/page.tsx"
import { T, LocaleSelector } from 'gt-next';
export default function Home() {
return (
Bienvenue dans mon application
Ce contenu sera traduit automatiquement.
);
}
```
`LocaleSelector` affiche un menu déroulant contenant les langues de votre `gt.config.json`.
***
## Étape 7 : Configurer les variables d’environnement (facultatif)
Pour voir les traductions en phase de développement, vous avez besoin de clés API de General Translation. Elles activent la **traduction à la demande** — votre application traduit le contenu en temps réel pendant que vous développez.
Créez un fichier **`.env.local`** :
```bash title=".env.local"
GT_API_KEY="your-api-key"
GT_PROJECT_ID="your-project-id"
```
Obtenez vos clés gratuitement sur [dash.generaltranslation.com](https://dash.generaltranslation.com/signup) ou en exécutant :
```bash
npx gt auth
```
Pour le développement, utilisez une clé commençant par `gtx-dev-`. Les clés de production (`gtx-api-`) sont réservées au CI/CD.
N’exposez jamais `GT_API_KEY` dans le navigateur et ne l’ajoutez jamais au contrôle de version.
Oui. Sans clés API, `gt-next` fonctionne comme une bibliothèque i18n classique. Vous n’aurez pas de traduction à la demande en développement, mais vous pouvez toujours :
* Fournir manuellement vos propres fichiers de traduction
* Utiliser tous les composants (``, ``, `LocaleSelector`, etc.)
* Exécuter `npx gt generate` pour créer des modèles de fichiers de traduction, puis les traduire vous-même
***
## Étape 8 : Vérifiez que tout fonctionne
Démarrez votre serveur de développement :
```bash
npm run dev
```
```bash
yarn dev
```
```bash
bun dev
```
```bash
pnpm dev
```
Ouvrez [http://localhost:3000](http://localhost:3000), puis utilisez le menu déroulant des langues pour changer de langue. Vous devriez voir votre contenu traduit.
En développement, les traductions se font à la demande : il se peut qu’un bref chargement apparaisse la première fois que vous passez à une nouvelle langue. En production, les traductions sont pré-générées et se chargent instantanément.
***
## Étape 9 : Traduisez les chaînes (pas seulement le JSX)
Pour les chaînes simples — comme les attributs `placeholder`, les valeurs `aria-label` ou le texte de `alt` — utilisez le hook **`useGT`**. Il fonctionne aussi bien dans les composants serveur que client :
```tsx title="app/contact/page.tsx"
import { useGT } from 'gt-next';
export default function ContactPage() {
const gt = useGT();
return (
);
}
```
Si vous préférez utiliser `async/await` dans les composants serveur, importez `getGT` depuis `gt-next/server` :
```tsx
import { getGT } from 'gt-next/server';
export default async function Page() {
const gt = await getGT();
return {gt('Hello')}
;
}
```
***
## Étape 10 : Déployer en production
En production, les traductions sont générées à l’avance au moment du build (sans appel d’API en temps réel). Ajoutez la commande translate à votre script de build :
```json title="package.json"
{
"scripts": {
"build": "npx gt translate && next build"
}
}
```
Définissez vos variables d’environnement de **production** chez votre hébergeur (Vercel, Netlify, etc.) :
```bash
GT_PROJECT_ID=your-project-id
GT_API_KEY=gtx-api-your-production-key
```
Les clés de production commencent par `gtx-api-` (et non par `gtx-dev-`). Obtenez-en une sur [dash.generaltranslation.com](https://dash.generaltranslation.com). Ne la préfixez jamais par `NEXT_PUBLIC_`.
C'est tout : votre application est désormais multilingue. 🎉
***
## Dépannage
`gt-next` stocke la préférence de langue de l’utilisateur dans un cookie appelé `generaltranslation.locale`. Si vous avez déjà fait des tests avec une autre langue, ce cookie peut prendre le pas sur votre sélection. Supprimez vos cookies, puis réessayez.
* [Chrome](https://support.google.com/chrome/answer/95647)
* [Firefox](https://support.mozilla.org/en-US/kb/delete-cookies-remove-info-websites-stored)
* [Safari](https://support.apple.com/en-mn/guide/safari/sfri11471/16.0/mac/11.0)
C’est normal. En développement, les traductions sont générées à la demande (votre contenu est traduit en temps réel via l’API). Ce délai **n’existe pas en production** — toutes les traductions sont pré-générées par `npx gt translate`.
Un texte ambigu peut entraîner des traductions inexactes. Par exemple, "apple" peut désigner le fruit ou l’entreprise. Ajoutez une prop `context` pour préciser le contexte :
```jsx
Apple
```
``, `useGT()` et `getGT()` prennent tous en charge l’option `context`.
***
## Prochaines étapes
**Voyez-le en action :** parcourez les [applications d'exemple fonctionnelles](/docs/next/tutorials/examples) pour voir les approches `gt-next` dans de vrais projets, ou accédez directement au [catalogue d'applications](https://app-catalog.generaltranslation.dev).
* [**Guide du composant ``**](/docs/next/guides/t) — Découvrez les variables, les pluriels et les schémas de traduction avancés
* [**Guide de traduction des chaînes**](/docs/next/guides/strings) — Découvrez en détail `useGT` et `getGT`
* [**Composants de variables**](/docs/next/guides/variables) — Gérez le contenu dynamique avec ``, ``, `` et ``
* [**Pluralisation**](/docs/next/api/components/plural) — Gérez les formes du pluriel avec le composant ``
* [**Traduire les métadonnées de page**](/docs/next/api/strings/get-gt#metadata) — Traduisez les titres, les descriptions et les balises OG avec `getGT`
* [**Déploiement en production**](/docs/next/tutorials/quickdeploy) — Configuration CI/CD, mise en cache et optimisation des performances
* [**Chaînes partagées**](/docs/next/guides/shared-strings) — Traduisez du texte dans des tableaux, des objets de configuration et des données partagées avec `msg()`