Integrating Internationalisation and Localisation in an NextJS app

When building an application for a global audience, providing content in multiple languages and adapting it to suit cultural and regional preferences is essential. This process involves Internationalization (i18n) and Localization (l10n). Next.js offers robust tools and libraries to manage this seamlessly.

In this blog, you’ll learn how to add internationalisation (i18n) and localisation (l10n) to a Next.js app. We’ll cover the basics, tools like next-i18next, a step-by-step setup guide, and key security tips to keep your multilingual app safe and user-friendly.

➡️ Prerequisites

Before diving into the implementation, you’ll need:

1. To gain a solid foundation in Next.js, it’s essential to become familiar with its basics, including pages, routing, and configuration files. For comprehensive guidance, you can refer to the official Next.js documentation.

2. Translation Files: These are JSON or other file formats containing the translations for each language. For example:
▪️For English: en.json
▪️For French: fr.json

3. These files will map keys to their translated values.

➡️ Key Concepts

✅ Internationalization (i18n)

This is the process of preparing your app to support multiple languages and regional differences. It involves designing your app to translate and display content in the user’s preferred language or region.

✅ Localization (l10n)

Localization is the implementation of translations and adaptations for a specific locale. For example, while en-US refers to English in the US, en-GB refers to English in the UK, which may have slight variations (e.g., “color” vs “colour”).

➡️ Tools and Libraries

Here are the tools and libraries commonly used for i18n in Next.js:

1. Next.js Built-in i18n Support

Starting from Next.js 10, i18n support is built into the framework. This approach allows you to define locales, such as a default locale, and even enables automatic locale detection.

2. Popular Libraries for i18n in Next.js

While the built-in support is great for basic use cases, you might need additional features for complex apps. Some popular libraries include:

▪️next-i18next: Simplifies the integration of i18n in Next.js by combining the power of i18next and react-i18next.
▪️react-intl: A library for formatting text, numbers, and dates based on a locale.
▪️i18next: A standalone i18n framework that offers extensive functionality.

➡️ Step-by-Step Guide to Adding i18n in Next.js

Let’s walk through the process of integrating i18n using both Next.js built-in support and the next-i18next library.

Step 1: Setting Up i18n in Next.config.js

Next.js allows you to configure i18n directly in your next.config.js file. Here’s how you can define supported locales and a default locale:

module.exports = {
    i18n: {
       locales: ['en', 'fr', 'es'], // List of locales supported by your app
       defaultLocale: 'en', // Default locale for users
       localeDetection: true, // Enable automatic locale detection
    },

Related read: Localization with react native i18n: A Comprehensive Guide

What Happens Here?

▪️locales: Specifies the available locales in your app.
▪️defaultLocale: Sets the fallback locale if no specific locale is detected.
▪️localeDetection: Allows Next.js to detect the user’s locale based on their browser or system settings.

Step 2: Creating Translation Files

Translation files are where you store your text strings for each language. Organize these files under public/locales in your project directory. Each locale will have its folder containing translation files.

Example directory structure:

public/
   locales/
     en/
       common.json
     fr/
       common.json
     es/
       common.json

Example content for common.json (English):

{
  "welcome": "Welcome to our website!",
  "greeting": "Hello, {name}!"
}

Step 3: Installing and Configuring Next-i18next

For more advanced i18n features, you can use the next-i18next library. Install it using:

npm install next-i18next react-i18next

Next, create a next-i18next.config.js file in your project root:

const path = require('path')npm install next-i18next react-i18next
module.exports = {
  i18n: {
    locales: ['en', 'fr', 'es'],
    defaultLocale: 'en',
  },
  localePath: path.resolve('./public/locales'),
};

Wrap your app with the appWithTranslation higher-order component (HOC) in pages/_app.js:

import { appWithTranslation } from 'next-i18next';

function MyApp({ Component, pageProps }) {
  return <Component {...pageProps} />;
}

export default appWithTranslation(MyApp);

Step 4: Fetching and Using Translations

To use translations in your components, import the useTranslation hook from react-i18next:

import { useTranslation } from 'react-i18next';

const HomePage = () => {
  const { t } = useTranslation('common'); // 'common' matches the JSON file name

  return (
   <div>
     <h1>{t('welcome')}</h1>
     <p>{t('greeting', { name: 'John' })}</p>
   </div>
  );
};

export default HomePage;

What Happens Here?

▪️The t function retrieves the translated string for the given key (e.g., welcome).
▪️You can pass variables to the translation string, such as { name: ‘John’ } in the example above.

Step 5: Adding a Language Switcher

To let users switch between languages, use the useRouter hook from Next.js:

import { useRouter } from 'next/router';

const LanguageSwitcher = () => {
  const router = useRouter();
  const { locale, locales, pathname, query, asPath } = router;

  const changeLanguage = (newLocale) => {
    router.push({ pathname, query }, asPath, { locale: newLocale });
  };

  return (
    <div>
      <p>Current language: {locale}</p>
      {locales.map((loc) => (
         <button key={loc} onClick={() => changeLanguage(loc)}>
            {loc.toUpperCase()}
         </button>
      ))}
    </div>
  );
};

export default LanguageSwitcher;

What Happens Here?

▪️The useRouter hook provides access to the current locale and the router. push method to programmatically change the locale.

Step 6: Formatting Dates, Numbers, and Currencies

To format dates and numbers, use the Intl API:

const date = new Date();
const formattedDate = new Intl.DateTimeFormat('fr-FR').format(date);
console.log(formattedDate); // Outputs: 05/03/2025 for French locale

➡️ Security Best Practices

▪️Escape Translations: Ensure all translations are properly sanitized to prevent XSS attacks.
▪️Restrict Locale Access: Only allow loading locales defined in your next.config.js.
▪️Avoid Sensitive Information: Never include sensitive data (e.g., user IDs) in your translation files.

coma

Conclusion

Integrating internationalisation and localisation in a Next.js app helps deliver region-specific experiences. With built-in features and tools like next-i18next, setup is simple and efficient. From locale settings to translation files, Next.js offers a smooth workflow for multilingual support.

This guide walked you through the full process, including dynamic language switching, content formatting, and essential security tips. With these practices, your app is ready for a global audience. Start localising to boost reach and user engagement.

Keep Reading

Keep Reading

  • Service
  • Career
  • Let's create something together!

  • We’re looking for the best. Are you in?