# General Translation Knowledge Base: General Translation vs. Localazy: which should you use?
URL: https://generaltranslation.com/en-GB/kb/general-translation-vs-localazy.mdx
Docs index: https://generaltranslation.com/llms.txt
Description: Choose General Translation to translate web and native app copy with shared terminology and build automation, while keeping reviewed catalogues or adopting inline components. Its CLI translates in your build, reviewers edit in the Dashboard, and pricing follows usage, not key counts. Localazy fits teams that need broader file-format support, built-in professional translation services, and native mobile over-the-air updates.
Category: Workflow Tools
Last updated: 2026-11-13
Authors: Jackie Chen
Published: 2026-11-13

Localazy is a hosted localisation platform built to work across stacks. You upload your source files with its CLI, translate the keys with Localazy AI, machine translation, your team, or Localazy's professional translators, and download the translations or deliver them from its CDN. Its formats cover web, Flutter, and native mobile projects. General Translation connects component or file translation to your build and shares terminology across projects; in React, Next.js, and Vue, you can also keep copy inline in the components.

## What Localazy does well

* **Many stacks, one platform.** The [CLI](https://localazy.com/docs/cli/the-basics) uploads and downloads [dozens of formats](https://localazy.com/docs/general/supported-file-formats), including Flutter ARB, XLIFF, Java properties, Qt TS, and Excel, and on Professional and above exports to other formats. Branching and release tags keep parallel work and app versions apart.
* **AI that follows your rules.** [Localazy AI](https://localazy.com/docs/general/localazy-ai) applies your glossary and style guide automatically and draws on previous translations and the notes you've added. Translators also get [screenshots](https://localazy.com/docs/general/screenshots) attached to keys. The CLI's [`localazy translate`](https://localazy.com/docs/cli/ai-translations) returns AI translations on demand in scripts and build pipelines.
* **Human translators when you need them.** You can order [professional translation or human review](https://localazy.com/docs/general/human-translation-services) of machine translation inside the platform, paid with the same credits as AI.
* **Delivery without a release.** The [Language CDN](https://localazy.com/docs/cdn/cdn-introduction) publishes translations to your users, and [over-the-air updates](https://localazy.com/docs/general/ota-updates) refresh strings in Android and iOS apps without an app store release.
* **Automation and reuse.** [Automations](https://localazy.com/docs/general/automations) can machine-translate new keys and apply translation memory when content arrives. [ShareTM](https://localazy.com/docs/general/what-is-localazy-sharetm), an opt-in shared translation memory, suggests translations approved in other Localazy projects.
* **Unlimited seats.** Every plan, including the free plan, has unlimited seats and languages, so translators and reviewers don't add cost.

## What Localazy still leaves to your engineers

In Localazy's managed-catalogue workflow, your app reads the files exported from the project. This React example uses react-i18next with an external source catalogue:

```tsx title="src/MembersNotice.tsx"
import { Trans } from 'react-i18next';

export function MembersNotice({ count }: { count: number }) {
  return (
    <p>
      <Trans
        i18nKey="workspace.members"
        count={count}
        components={{ membersLink: <a href="/settings/members" /> }}
      />
    </p>
  );
}
```

```json title="locales/en.json"
{
  "workspace": {
    "members_one": "Your workspace has {{count}} member. <membersLink>Invite your team</membersLink>",
    "members_other": "Your workspace has {{count}} members. <membersLink>Invite your team</membersLink>"
  }
}
```

`localazy upload` and `localazy download` can run in CI, and automations can translate new keys as they arrive. Its separate [`localazy translate`](https://localazy.com/docs/cli/ai-translations) command can also return translations synchronously to a build script without storing them as project phrases. In the catalogue example above, that means maintaining the message keys, plural entries, and placeholder mappings alongside the component. Inline defaults and extraction can automate catalogue creation in supported libraries; they still leave the catalogue, context, and delivery configuration to maintain.

Localazy&#39;s free plan covers up to 200 source keys. Paid plans scale by managed source keys: Professional includes 1,000 keys for $34 a month billed annually, and Business includes 10,000. Paid plans include an AI translation allowance; beyond it, AI, machine, and human translation use credits, with Localazy AI at $0.0035 to $0.008 per word. Both Localazy and General Translation allow unlimited users, so seats aren&#39;t the cost distinction here. (See [Localazy pricing](https://localazy.com/pricing), checked November 2026.)

## Localazy vs. General Translation at a glance

| Feature                 | Localazy                                                                                              | General Translation                                                                                                                                                 |
| ----------------------- | ----------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Where strings live      | Keys in your source files, uploaded to a Localazy project                                             | In your code inside [`<T>`](/docs/react/reference/components/t), or in the resource files you already have                                                          |
| How code connects       | Upload/download in CI; `localazy translate` for synchronous, on-demand output                         | [`npx gt translate`](/docs/cli/reference/commands/translate) in your build, or [Locadex](/docs/platform/locadex/quickstart) pull requests in Next.js and React apps |
| Who translates          | Localazy AI, machine translation, your team, or Localazy&#39;s professional translators               | AI with context from your code, Glossary, and Custom Prompts, reviewed by your team in the Dashboard                                                                |
| Context for each string | AI uses notes, key names, glossary, style guide, and earlier translations; screenshots help reviewers | Marked JSX and notes, or resource-file metadata; shared Glossary and Custom Prompts across assigned projects                                                        |
| File formats            | Dozens, including Flutter ARB, XLIFF, and Java properties                                             | JSX, plus [JSON, YAML, PO, Markdown, iOS, Android, .resx, and more](/docs/cli/reference/formats/json-files)                                                         |
| Delivery                | Downloaded files, the Language CDN, and Android and iOS OTA                                           | Local files in your build, or General Translation&#39;s CDN for React and Next.js                                                                                   |
| Pricing                 | Managed source-key plans with included AI allowances and extra credits; unlimited seats               | [Usage-based translation](https://generaltranslation.com/pricing), without key-count subscriptions or seat charges                                                  |

## Why teams choose General Translation over Localazy

In React, Next.js, and Vue, General Translation translates the copy in your components, so there&#39;s no source catalogue to maintain. Here is the same notice with `gt-react`, after [setting up its provider](/docs/react/react-quickstart):

```tsx title="src/MembersNotice.tsx"
import { T, Plural, Num } from 'gt-react';

export function MembersNotice({ count }: { count: number }) {
  return (
    <T>
      <p>
        <Plural
          n={count}
          singular={<>Your workspace has <Num>{count}</Num> member.</>}
        >
          Your workspace has <Num>{count}</Num> members.
        </Plural>{' '}
        <a href="/settings/members">Invite your team</a>
      </p>
    </T>
  );
}
```

The singular sentence, fallback sentence, and link stay in the component. [`npx gt translate`](/docs/cli/reference/commands/translate) uses them to generate the target language&#39;s plural forms; [`<Plural>`](/docs/react/reference/components/plural) selects a form at render time using the locale and count.

* **Faster.** The English plural branches and link live together, so a copy change stays in the component&#39;s pull request. The CLI extracts the marked content, generates changed translations, and downloads them before the build. Engineers don&#39;t maintain a second English message for this UI in a source catalogue.
* **Usage-based billing.** Localazy&#39;s plans step up as your managed source keys grow, and translation past the included allowance is bought as credits. General Translation bills for the translation work you request and reuses matching completed translations, so a growing catalogue doesn&#39;t move you to a higher plan. (See [usage rates](https://generaltranslation.com/pricing/usage).)
* **JSX structure as context.** Localazy AI translates each key with its notes, glossary, and earlier translations. General Translation translates the marked block, so the plural branches and the link in the notice above reach translation together with any `context` note, and reviewers correct the result in the [Dashboard](/kb/review-translations). Comments in Android `strings.xml` and Apple `.strings` files carry the same kind of note for native strings. (See [how General Translation sends context](/kb/ai-translation-context).)
* **Lower risk.** Adopt the service with your existing i18next or next-intl library and reviewed catalogues; moving to inline components is a separate decision. The CLI also translates iOS String Catalogs, `.strings`, `.stringsdict`, Android `strings.xml`, and PO files for your existing release process. With all translations loaded locally, the MIT-licensed `gt-react` and `gt-next` libraries render without a GT account or runtime service calls.

Ramp localises its dashboard, landing page, and iOS app into 11+ locales with General Translation. (See [General Translation for enterprise](https://generaltranslation.com/enterprise).)

## When Localazy is the better fit

Choose Localazy when one project has to cover formats such as Flutter ARB, XLIFF, or Java properties, when you want to order professional human translation in the same platform, when native mobile apps need over-the-air string updates without a release, or when you want a shared translation memory across Localazy projects.

## Moving from Localazy to General Translation

1. **Export and back up.** Keep a source snapshot in your repository, [download](https://localazy.com/docs/cli/download-reference) the complete, reviewed translations that match it, and back up both. Confirm that target entries are translated, not source-language fallbacks, and finish incomplete locales first.
2. **Pause Localazy&#39;s writes.** Before General Translation writes any files, pause the Localazy upload and download jobs and automations that write to your repository. If two tools write the same files, whichever writes last wins.
3. **Set up context.** Configure `gt.config.json` for those files, copy your glossary into a Context Group and your style guide into Custom Prompts, and keep per-string notes in source-file comments or [keyed metadata](/docs/cli/reference/keyed-metadata), so the first translations use them.
4. **Upload.** Run [`npx gt upload`](/docs/cli/reference/commands/upload) to import the downloaded translations.
5. **Translate and verify.** Run [`npx gt translate`](/docs/cli/reference/commands/translate) and check one locale in the app. Keep i18next or next-intl rendering the catalogues, and keep any native over-the-air delivery you still need in place until its replacement is ready.

## Is General Translation an alternative to Localazy?

Yes, for product copy in React, Next.js, and Vue components and in the file formats the CLI supports. Your reviewed translations, glossary, and per-string notes carry over, and an i18next or next-intl app keeps its library. What changes is where translation happens: in your build instead of a platform you sync with. Native over-the-air updates and in-platform professional translators are the parts you&#39;d replace with app releases and your own reviewers.

## Related questions

- [General Translation vs. a TMS (Crowdin, Lokalise, Phrase)](https://generaltranslation.com/en-GB/kb/general-translation-vs-tms.mdx): Choose General Translation when developers want translation generation, code-derived context, and review connected to product releases. Keep your existing catalogues and rendering library, or author inline JSX without translation keys. A TMS fits programmes centred on language vendors, CAT editors, and XLIFF exchange; its integrations can automate the file transfers.
- [General Translation vs. SimpleLocalize: which should you use?](https://generaltranslation.com/en-GB/kb/general-translation-vs-simplelocalize.mdx): Choose General Translation to keep UI copy and translation context in your components, generate changed messages before the build, and review wording without seat fees. You can also keep existing i18next or next-intl catalogues. SimpleLocalize fits teams that want a keyed translation editor with on-page editing, customer-specific wording, and native mobile over-the-air updates.
- [Crowdin alternatives: General Translation vs. Crowdin](https://generaltranslation.com/en-GB/kb/general-translation-vs-crowdin.mdx): Choose General Translation to keep copy in your components and generate translations with your build. Crowdin manages translation projects around resource files, translators, and review workflows, which engineers connect to the app and maintain as the product changes. Crowdin remains a strong fit for open-source community translation and vendor-led programmes.
- [What's the best continuous localisation tool for teams that ship daily?](https://generaltranslation.com/en-GB/kb/best-continuous-localization-tools.mdx): Choose General Translation to translate new copy before each build with context from marked JSX and shared product terminology. Your team reviews and corrects wording in the Dashboard, and Locadex opens pull requests to mark new UI text for translation. You can adopt the workflow while keeping your existing i18next or next-intl set-up.
- [How do I give AI translation enough context for software strings?](https://generaltranslation.com/en-GB/kb/ai-translation-context.mdx): Translate complete messages with meaning notes, placeholder roles, length limits, and shared terminology. General Translation's CLI extracts marked JSX as a structured block and carries context notes into generation. For existing JSON and YAML catalogues, keyed metadata supplies per-string instructions. Context Groups apply your Glossary and Custom Prompts across assigned projects, and reviewers correct the output in the Dashboard.

## Previous and next questions

- Previous question: [Can you localise software without translators or a localisation team?](https://generaltranslation.com/en-GB/kb/localize-without-translators.mdx)
- Next question: [General Translation vs. SimpleLocalize: which should you use?](https://generaltranslation.com/en-GB/kb/general-translation-vs-simplelocalize.mdx)

## Sitemap

See the [Knowledge Base sitemap](https://generaltranslation.com/en-GB/kb/sitemap.md) for every article.