
NextJS, a well-known framework among React developers, provides multiple libraries that create a very developer-friendly environment. The most popular ones are i18Next, [next-translate](/blog/posts/next-translate/) and, our main focus in this blog post, [next-18next](https://github.com/isaachinman/next-i18next), a translation library that does a fantastic job helping in translation management. The following blog post will show you how to set up next-i18n in your NextJS app and [manage translations with SimpleLocalize](/). Take a look at our [demo app](https://github.com/simplelocalize/simplelocalize-next-i18next) for the reference.

## About next-i18next

Next-i18next is a NextJS framework that completes and expands the possibilities of NextJS basic i18n setup, which focuses mainly on automation of i18n routing using locales. Next-i18next uses i18next and react-i18next at its core, but it is simple to install, and the configuration takes only a few steps. 

Next-i18next offers additional benefits for NextJS app localization, like:

- easy integration with translation content management like SimpleLocalize
- components/hooks for React components translation
- production ready with SSG/SSR support (Static Site Generation and Server-Side Rendering)
- allows namespaces
- customizable interpolation
- supports code-splitting
- easy setup and configuration

The standard file structure for next-i18next with namespaces will look like this:

```bash
.
├── en
│   ├── common.json
│   └── home.json
├── es
│   ├── common.json
│   └── home.json
├── it
│   ├── common.json
│   └── home.json
└── pt_PT
    ├── common.json
    └── home.json
```

There are four **languages** in our app (`en`, `es`, `it` and `pt`) and two **namespaces**, `common` and `home`. **A namespace is usually one page of your website or app.** In such a multiple-file setup, next-i18next loads only the translations that it needs to display from a selected locale.

![translation files with namespaces sample (i18next)](/docs/next-i18next/sample-common-namespace-with-translations-in-json-i18next.png)


## Next-i18next configuration

The basic next-i18next configuration takes only few steps and will allow you to improve translation management in your app. See the below step-by-step guide to get started.

### Install next-i18next

Use the simple command below to start with next-i18next installation with NPM or Yarn:

```bash
npm install --save next-i18next
```

### Create i18n configuration file

Now, create a configuration file in the project's root, `./next-i18next.config.js`.

```typescript
// 📦 file: ./next-i18next.config.js

module.exports = {
  i18n: {
    defaultLocale: 'en',
    locales: ['en', 'es', 'it', 'pt_PT'],
  },
};

```

### Add next-i18next to your NextJS app

The last step in the configuration is importing next-i18next configuration into next.config.js file.

```typescript
// 📦 file: ./next.config.js

const {i18n} = require("./next-i18next.config");
const nextConfig = {
  reactStrictMode: true,
  i18n
}

module.exports = nextConfig
```

### Create your file structure 

When next-i18next is installed and configured, create your file structure for translations with languages and namespaces. Check the standard structure we described at the beginning of this blog post.

The root directory for your translations is `/locales/{lang}/{ns}`.json where `lang` is your locale (en, es, it, pt) and `ns` is your namespace (common, home). 

## How to manage next-i18next translation files?

Next-i18next is a great framework which makes translation management way easier. Use it together with SimpleLocalize translation editor to manage localization process of your app like a pro. 😎

With SimpleLocalize, you can easily add new languages, manage existing translations and even **auto-translate all translations**! See how to get started and connect your NextJS app with next-i18next and SimpleLocalize.

### Install SimpleLocalize CLI

Use [SimpleLocalize CLI](/docs/cli/get-started/) to easily extract translation keys from your project and upload them to SimpleLocalize translation editor. 

Issue the command below to start the installation.

```bash
curl -s https://get.simplelocalize.io/2.5/install | bash
```

Next, **create a configuration file** that will integrate your project with your SimpleLocalize account in no time.

```yaml
# 📦 file: ./simplelocalize.yml
apiKey: YOUR_PROJECT_API_KEY
downloadFormat: single-language-json
downloadPath: ./locales/{lang}/{ns}.json

uploadFormat: single-language-json
uploadPath: ./locales/{lang}/{ns}.json
```

### Upload your translation files to SimpleLocalize

To upload your translations to SimpleLocalize project, use the installed CLI by running the command below:

```bash
$ simplelocalize upload
```

Or check [more import options](/docs/cli/upload-translations/) available for multiple file formats.

![Uploading translations with namespaces for next-i18next](/docs/next-i18next/upload-translations-with-namespaces.mp4)


### Translate your app with SimpleLocalize online editor

Now, the best part of translation management begins. Log in to your SimpleLocalize account, open your project and start managing your translations. Use [SimpleLocalize online translation editor](/translation-editor/) to edit translations, add more languages, or [translate them automatically with DeepL or Google Translate](/blog/posts/how-to-use-auto-translation/). **Share the project with your team members** and send access to translators using intuitive [access sharing options](/docs/general/project-sharing/).

![Manage your translation strings in Translation Editor](/video/translation-editor-change-translations.mp4)

[Sign up for free Community plan](/register/) and start managing your localization process in your way in our feedback-driven app.

### Download translations to your app

When you are done with editing your translation, [download](/docs/cli/download-translations/) localized files using CLI, or with one of multiple supported file format.

```bash
$ simplelocalize download
```

![Downloading translations with namespaces for next-i18next](/docs/next-i18next/download-translations-with-namespaces.mp4)


### Next-i18next demo app

To try out how next-i18next goes with NextJS and SimpleLocalize and check an **example of NextJS localization**, run our demo app locally on your computer. Download the files from [Github repository](https://github.com/simplelocalize/simplelocalize-next-i18next) and test how it works.

![Example next-i18next project with NextJS](/blog/next-i18next-example.png)


## Localize your NextJS app with SimpleLocalize

App or website localization can be a challenging  task, but you can make it a pleasant experience with great tools and localization frameworks. NextJS has a variety of external libraries that create a comfortable base for your work. Not only next-i18next, but also next-translate or next-intl and much more. Integrating your app with SimpleLocalize will improve your satisfaction during your app localization process.

![import multi-language-json to simplelocalize](/blog/import-your-translations-from-file.png)

In case you have any doubts or need help with integrating your project with SimpleLocalize, check our [documentation](/docs/) or contact Jakub directly at jakub@simplelocalize.io.


How to translate NextJS app with next-i18next?


NextJS, as a very popular framework among React programmers, offers a variety of features and external libraries,
that create a very developer-friendly environment. One of them is [next-translate, a translation library](https://github.com/vinissimus/next-translate) that well known for its simple set up and use.
In this blog post, you will learn to configure next-translate in your NextJS app,
and to [manage translations with SimpleLocalize](/) assist.


## About next-translate

Next-translate is a great choice for managing your translations in your NextJS application. It is easy to configure and use, even for beginners.
It supports basic internationalization (i18n) like plurals or Trans component (to use HTML inside translated text),
loads only necessary translations which extremely saves your app memory, and it doesn't take a lot of storage. 

The library uses namespaces that allow you to split translations into multiple files. The standard file structure looks like this:

```bash
.
├── en
│   ├── common.json
│   └── home.json
├── es
│   ├── common.json
│   └── home.json
├── pl
│   ├── common.json
│   └── home.json
└── fr
    ├── common.json
    └── home.json
```

There are four **languages** in our app (`en`, `es`, `fr` and `pl`) and two **namespaces**, `common` and `home`. **A namespace is usually one page of your website or app.** Such file structure is clear and easy to manage. Thanks to this setup, next-translate will only load the translations that are needed to display translated content in a selected locale. 

![Sample common namespace with translations in JSON](/docs/next-translate/sample-common-namespace-with-translations-in-json.png)

## Next-translate configuration

The configuration of next-translate takes only a few steps, and they are straightforward to follow. See below the step-by-step setup for your NextJS app.

### Install next-translate

To get started, install next-translate. You can do that with either NPM or Yarn. Simply run the command in your console.

```bash
npm install --save next-translate
```

### Create i18n configuration file

Create a configuration file, i18n.json, in your project's root. It will look like below, where you set the locales you will use in your project, the default language and your namespaces (one for each page).

```json
{
  "locales": ["en", "es", "fr", "pl"],
  "defaultLocale": "en",
  "pages": {
    "*": ["common"],
    "/": ["home"]
  }
}

```

### Create your namespaces file structure

The next step is to create your file structure with languages and namespaces. Check the example above for the file structure. 

The root directory for your translations is `/locales/{lang}/{ns}.json` where `lang` is your locale (en, es, fr, pl) and `ns` is your namespace (common, home).

### Add next-translate to your app

The last step of the configuration of next-translate is to add it to your app, to `next.config.js` file.

```typescript
// 📦 file: ./next.config.js
const nextTranslate = require('next-translate')

module.exports = nextTranslate({
  webpack: (config, { isServer, webpack }) => {
    return config;
  }
})
```

And that's all. With those four steps, you are ready to translate your app with SimpleLocalize.

## How to manage next-translate translation files?

SimpleLocalize can help you translate your keys automatically and manage them in a great translation editor. Adding a new language will become as effortless as you could ever imagine. How to get started, then?

### Install SimpleLocalize CLI

[SimpleLocalize CLI](/docs/cli/get-started/) will get translation files from your project, extract them and upload to SimpleLocalize.

Run the command below to start the installation.

```bash
curl -s https://get.simplelocalize.io/2.5/install | bash
```

Next, **create a configuration file** to smoothly integrate your project with your SimpleLocalize account.

```yaml
# 📦 file: ./simplelocalize.yml
apiKey: YOUR_PROJECT_API_KEY
downloadFormat: single-language-json
downloadPath: ./locales/{lang}/{ns}.json

uploadFormat: single-language-json
uploadPath: ./locales/{lang}/{ns}.json
```

### Upload translations to SimpleLocalize

You can use the installed CLI to [upload your translation files](/docs/cli/upload-translations/) to your project in
SimpleLocalize. Run the command below:

```bash
$ simplelocalize upload
```

![Uploading translations with namespaces for next-translate](/docs/next-translate/upload-translations-with-namespaces.mp4)

### Use SimpleLocalize to translate your app

Now, the fun begins. Use SimpleLocalize translation editor to change your translations, add new languages, or translate the keys automatically with DeepL or Google Translate. [Translation editor features](/blog/posts/translation-editor-explained/) will help you control translation progress and work with translators within one translation management system. 

![Manage your translation strings in Translation Editor](/video/translation-editor-change-translations.mp4)

[Sign up for free Community plan](/register/) to get your translations on track for you and your team.

### Download translations to your project

When your translation changes are ready, you can [download](/docs/cli/download-translations/)
them to your project with a CLI command:

```bash
$ simplelocalize download
```

![Downloading translations with namespaces for next-translate](/docs/next-translate/download-translations-with-namespaces.mp4)

### Next-translate demo app

You can try how i18n next-translate library works in a NextJS app with our demo.
Check the [GitHub repository](https://github.com/simplelocalize/simplelocalize-next-translate) and run it locally on your computer.

![Example next-translate project with NextJS](/blog/next-translate-example-application.jpg)

## Localize your NextJS app with SimpleLocalize

Localization of a website or app can be a challenging task. Fortunately, there are great tools that help both developers and translations to do their job with ease. SimpleLocalize connects the workflow for all team members of the project and helps to manage the translation process efficiently. Next-translate is a great start to begin the i18n of your NextJS app. 

![import multi-language-json to simplelocalize](/blog/import-your-translations-from-file.png)

In case you have any doubts or need help with integrating your project with SimpleLocalize, check our [documentation](/docs/) or contact Jakub directly at jakub@simplelocalize.io.


How to translate NextJS app with next-translate?


## Code-splitting for resources

Code-splitting is a built-in function in many code bundlers like [Webpack](https://webpack.js.org). It's used mostly to lazy load only required JavaScript code or other resources.
It helps in improving application performance by loading only required parts of the application, instead of fetching all resources at once.
This is a perfect solution for localization purposes to load translations for only one language instead of all of them to speed up your web application.

> Medium-sized web application with about 1000 unique translation keys can contain about 50kb translated messages for one language. If you would
> support 10 languages in your app, whole translation file could have size nearly 1 megabyte.

Learn more about [code-splitting in React](https://reactjs.org/docs/code-splitting.html).

## How to lazy load JSON file in React?

Here is the asynchronous function TypeScript, which accepts `languageKey` as a `string` and returns a loaded JSON file as an JavaScript object.

```typescript
const loadJson = (languageKey: string): Promise<any> => {
  return new Promise((res, rej) => {
    import(`../assets/i18n/${languageKey}-messages.json`).then((data) => {
      res(data?.default);
    });
  });
};
```

## How to use lazy load in React app?

Here is the full example code for lazy loading translations from local JSON files. The code is written in TypeScript,however, it should be easy to convert into plain JavaScript.

```typescript jsx
import {useState} from "react";

const [locale, setLocale] = useState('en-US');
const [messages, setMessages] = useState({});

// first useEffect
useEffect(() => {
  const locale = window.navigator.language;
  setLocale(locale);
}, []);

// second useEffect
useEffect(() => {
  loadJsonAsync = async () => {
    const messages = await loadJson(locale);
    setMessages(messages);
  }
  loadJsonAsync();
}, [locale])

// use your messages
```

React will invoke:
- the first `useEffect` hook only **once on every page re-render**. We are getting the language from web browser. Learn more about [navigator.language](https://developer.mozilla.org/en-US/docs/Web/API/Navigator/language) object.

- the second `useEffect` hook when `locale` value is changed to lazy load different JSON file with translations.

> You cannot invoke async functions in `useEffect` React hook, that is why we create a new `loadJsonAsync` function.

Check example [how to load translations from backend](https://github.com/simplelocalize/react-intl-simplelocalize/blob/master/src/index.js) using a standard fetch API.


## Use loaded JSON messages with IntlProvider

To use loaded JSON messages with FormatJS, you can simply pass `locale` variable and `messages` object as props
to IntlProvider.

```tsx
<IntlProvider 
  locale={locale} 
  messages={messages}
>
          {children}
</IntlProvider>
```

`children` variable should contain your React component or even a whole application (e.g., `<App/>`) in which you want to provide translations.


Translation Hosting

SimpleLocalize CLI

REST API

Auto-translation

Alternative translations

React localization

How to translate NextJS app with next-i18next?

How to translate NextJS app with next-translate?

How to use code splitting with JSON files in React application