Integrate Localazy with Strapi

These integration guides are not official documentation and the Strapi Support Team will not provide assistance with them.

What Is Localazy?

Localazy is a highly automated translation management platform that makes localization workflows simple for a wide range of software, including web and mobile applications. When you integrate Localazy with Strapi, it turns your headless CMS architecture into a multilingual content hub without the headaches of juggling translations across multiple systems. To understand the differences between traditional and headless CMS, you might find our headless CMS comparison helpful.

This localization plugin creates a direct connection between content management and translation. It syncs content automatically between Strapi and Localazy, eliminating tedious copy-pasting or file importing that typically bogs down localization work.

Why Integrate Localazy with Strapi

Integrating Localazy with Strapi solves the headaches of multilingual content management while keeping your headless architecture intact. Unlike all-in-one CMS solutions, this approach preserves Strapi's API-first flexibility and the advantages of a headless CMS while adding specialized translation capabilities.

The combination eliminates manual work entirely. Content syncs automatically between platforms; you handle languages in Localazy while new content flows directly from Strapi for translation. This automation, combined with Strapi's internationalization features, keeps your content pipeline running smoothly as your multilingual needs grow.

Security improves through the clear separation of roles. Translators work in Localazy's dedicated environment without needing Strapi admin access. This approach aligns with best headless CMS security practices, reducing risks while keeping workflows efficient. This allows translation teams to focus on what they do best without navigating complex CMS interfaces.

Localazy's Glossary and Screenshots OCR features create context-rich translation environments. These tools help translators better understand content context, improving quality and reducing revision cycles. Advanced features solve duplicate issues, manage permissions, and create automated workflows that fit your specific content processes, boosting your content workflow efficiency.

API-first teams maintain headless principles while adding localization, taking advantage of an API-first approach. Unlike all-in-one CMS solutions, this approach preserves Strapi's API-first flexibility, allowing you to enjoy the API-first CMS benefits, while adding specialized translation capabilities. You can continue building custom frontends and mobile apps that consume multilingual content through Strapi's REST or GraphQL APIs. If you're unsure which API style suits your project, consider reading about REST vs GraphQL.

How to Integrate Localazy with Strapi

Setting up Localazy with Strapi requires attention to prerequisites, proper authentication, and careful configuration. Follow these steps to create a smooth localization workflow for your headless CMS.

Prerequisites

Before starting, ensure that your development environment meets the requirements. You will need Strapi v5 running in your environment, as the latest Localazy plugin works specifically with this version. Localazy has shifted focus to supporting Strapi v5, so upgrading is recommended for best integration, though Strapi v4 support has not been officially deprecated.

Your system needs Node.js version 18 or higher, along with npm or yarn for package management. You'll also need a Localazy account. New accounts get a 14-day trial, but ongoing use requires at least an Autopilot plan to access all integration features.

Make sure you have the Strapi Internationalization (i18n) plugin installed and set up in your project—i18n for Static Sites provides a helpful guide. This forms the foundation for any localization work in Strapi, and the Localazy plugin builds on this functionality.

Step 1: Install Required Plugins

To integrate Localazy with Strapi, you need two essential plugins working together. Start by installing the Strapi Internationalization plugin if you haven't already. This enables multi-language content management within Strapi and must be configured before adding Localazy.

Next, install the Localazy Strapi plugin from the official marketplace. You can add it through your Strapi admin panel in the Marketplace section or use npm or yarn commands in your project directory. The marketplace installation ensures you get the latest compatible version with automatic updates. You need to type the following commands.

npm install @localazy/strapi-plugin
# or
yarn add @localazy/strapi-plugin

After installation, restart your Strapi server to make sure both plugins load properly into your admin interface.

Step 2: Connect Localazy with Strapi

The connection uses a secure OAuth flow to establish communication between Strapi and Localazy. Go to your Strapi admin panel and look for the flag icon in the left sidebar to open the Localazy plugin interface.

Click the flag icon to access the plugin screen. For first-time connections, you'll see a login interface with a "Login with Localazy" button. Clicking this button starts the OAuth process, opening a new browser tab that takes you to Localazy's authorization page.

Log in with your Localazy credentials. The system automatically detects your Strapi project's default language settings and uses this when creating or connecting to a Localazy project. You can select an existing Localazy project or create a new one directly from this screen.

After selecting or creating a project, click "Authorize" to complete the connection. You'll see a success message and can return to your Strapi admin panel where the connection will be active. This creates a persistent connection that stays active until manually disconnected, with the access token securely stored in your Strapi database.

Step 3: Configure Content Transfer

With the connection established, you need to specify what content should go to Localazy for translation. Go to Settings > Localazy Settings > Content Transfer Setup in your Strapi admin panel. This screen lets you select specific content types and fields that need translation, preventing unnecessary clutter in your workflow.

When configuring your content transfer, it's important to consider how your application will serve an international audience. For more insights on building applications for an international audience, you can refer to this resource.

Review your content types and select only those containing translatable content. This focused approach ensures translators work on relevant material and reduces complexity. Consider content relationships when making selections. Related content should typically be translated together for consistency.

The configuration also lets you specify which fields within selected content types need translation. Not everything requires translation. URLs, technical identifiers, or numeric values often stay consistent across languages.

Step 4: Upload and Manage Content

Once your content transfer settings are configured, you can start uploading source content to Localazy. The plugin provides a simple upload interface where you can push selected content with one click. During upload, the plugin creates human-readable keys for your source strings, making translation more intuitive for your team.

After uploading, your content becomes available in Localazy where you can choose from several translation approaches. Use machine translations for quick drafts, invite team members to contribute translations, or order professional translation services through Localazy's translator network.

The plugin handles synchronizing translations back to Strapi. When translations are completed in Localazy, you can download them to your Strapi instance with another single click. The system automatically creates new language versions of your content and updates the appropriate fields.

Project Example: Multilingual Blog API

Here's how to build a multilingual blog API that demonstrates practical integration of Localazy with Strapi. This example shows how to create a scalable content system that automatically handles translation workflows while maintaining security and performance.

Project Structure and Setup

For this blog, you'll create a content architecture that separates translatable from non-translatable fields. The blog includes three main content types: Articles, Authors, and Categories. Articles contain translatable fields like title, content, and excerpt, while metadata such as publication dates and author IDs remain consistent across languages.

The Strapi REST API automatically generates endpoints for each content type, providing the foundation for content delivery. You'll use both REST and GraphQL endpoints to optimize content retrieval—REST for bulk operations and GraphQL for precise, relationship-heavy queries.

Content Type Configuration

Your Article content type should structure fields strategically for translation efficiency. Translatable fields include title, slug, content, and meta description, while author relationships, publication status, and timestamps remain language-neutral. This separation allows Localazy to focus only on content requiring translation, reducing processing overhead and maintaining content integrity.

Configure the internationalization settings in Strapi to enable locale-specific versions of your articles. Each article can exist in multiple languages while maintaining relationships to shared resources like author profiles and category taxonomies.

API Integration Code

Here's the core integration code for exporting content from Strapi to Localazy:

async function exportContentToLocalazy(contentType, locale = 'en') {
  const { data } = await strapi.client.find(contentType, {
    locale,
    populate: ['translatable_fields', 'media.file'],
  });
  
  const localazyPayload = data.map(item => ({
    id: item.id,
    content: {
      title: item.title,
      content: item.content,
      excerpt: item.excerpt
    },
    metadata: {
      lastUpdated: item.updatedAt,
      contentType: contentType
    }
  }));
  
  const response = await fetch('https://api.localazy.com/projects/123/imports', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${LOCALAZY_API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(localazyPayload)
  });
  
  return response.json();
}

The import function brings translations back into Strapi:

async function importTranslationsFromLocalazy(contentType, locale) {
  const response = await fetch(`https://api.localazy.com/projects/123/exports?locale=${locale}`, {
    headers: {
      'Authorization': `Bearer ${LOCALAZY_API_KEY}`
    }
  });
  
  const translations = await response.json();
  
  for (const translation of translations) {
    await strapi.client.update(contentType, translation.id, {
      data: {
        title: translation.content.title,
        content: translation.content.content,
        excerpt: translation.content.excerpt
      },
      locale
    });
  }
  
  return { success: true, count: translations.length };
}

Automated Workflow Implementation

Automation turns your blog from a manual process into a seamless content machine. Set up webhook handlers that trigger translation workflows automatically when content changes:

module.exports = {
  async afterUpdate(event) {
    const { result, params } = event;
    
    if (params.locale === 'en' && result.publishedAt) {
      try {
        await exportContentToLocalazy('articles', params.locale);
        console.log(`Article exported for translation: ${result.title}`);
      } catch (error) {
        console.error('Translation export failed:', error);
      }
    }
  }
};

Security implementation uses Strapi's RBAC system to create translator-specific roles with limited permissions. Create API tokens with read-only access for Localazy integration, ensuring translators can access content without compromising your CMS security.

Performance optimization uses Strapi's Content API capabilities through selective field population and query filtering. Use GraphQL for complex queries that need to fetch articles with their categories and author information across multiple languages, while REST endpoints handle bulk operations like exporting all articles for translation.

This implementation creates a production-ready blog API that scales across languages while maintaining content quality through automated translation workflows. The separation between Strapi and Localazy ensures each platform handles what it does best—content management and translation management respectively.

Strapi Open Office Hours

If you have any questions about Strapi 5 or just would like to stop by and say hi, you can join us at Strapi's Discord Open Office Hours, Monday through Friday, from 12:30 pm to 1:30 pm CST: Strapi Discord Open Office Hours.

For more details, visit the Strapi documentation and Localazy documentation.