# General Translation Knowledge Base: Tiempo de compilación, tiempo de ejecución o proxy de traducción: ¿cómo deberías entregar las traducciones?
URL: https://generaltranslation.com/es/kb/build-time-vs-runtime-translation.mdx
Docs index: https://generaltranslation.com/llms.txt
Description: Usa General Translation para generar las traducciones conocidas de tu aplicación antes del lanzamiento y luego inclúyelas en el paquete junto con tu código o cárgalas desde su CDN. Con los paquetes, los textos quedan vinculados a un lanzamiento; las ediciones publicadas en la CDN pueden llegar a los nuevos renderizados sin desplegar código. Usa la traducción en el momento de la solicitud para el contenido que un visitante necesita de inmediato, y un proxy cuando no puedas modificar el código del sitio.
Category: Internacionalización
Last updated: 2026-11-12
Authors: Jackie Chen
Published: 2026-11-12

Hay cuatro formas principales de hacer llegar una traducción a un visitante: incluirla en el paquete de tu aplicación al compilarla, cargarla desde una red de distribución de contenido (CDN) cuando se renderiza la página, traducirla mediante una API mientras se procesa la solicitud o insertarla en tu HTML mediante un proxy o un script situado delante de tu sitio. De esta elección depende de qué dependerá tu aplicación en producción, cómo llegará a los usuarios una traducción corregida y si los motores de búsqueda podrán indexar cada idioma.

Generar una traducción no es lo mismo que cargarla. Una CDN sirve traducciones que ya has generado; no necesita llamar a un modelo de IA en cada visita. Para los textos de la aplicación que ya conoces antes del despliegue, genera las traducciones con antelación y sírvelas desde el paquete o desde una CDN. El contenido que se añada más adelante puede traducirse al publicarse o en un trabajo en segundo plano; usa la traducción en el momento de la solicitud cuando un visitante necesite un resultado inmediato. El proxy está pensado para sitios cuyo código no puedes o no quieres modificar.

## ¿En qué se diferencian los enfoques de entrega?

| Enfoque                                                                                                                                                                                       | Cómo funciona                                                                                          | De qué depende Producción                                                     | Cómo llega una traducción corregida a los usuarios                                                                          | Adecuado para                                                                               |
| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------- |
| Incluir en el paquete en tiempo de compilación                                                                                                                                                | Los archivos de traducción se generan antes de la compilación y se importan por configuración regional | Solo de tu app                                                                | Con el siguiente despliegue                                                                                                 | La mayoría de las apps, incluidas las páginas estáticas, ISR y server-rendered              |
| Cargar desde una CDN en tiempo de ejecución                                                                                                                                                   | La app obtiene las traducciones generadas de cada configuración regional                               | De la CDN                                                                     | Publica la edición y luego actualiza las cachés de traducciones y de páginas; el HTML totalmente estático debe recompilarse | Apps en las que los revisores corrigen textos entre lanzamientos                            |
| Traducir bajo demanda                                                                                                                                                                         | El servidor solicita el texto a una API de traducción durante la solicitud                             | De la API de traducción, en las solicitudes que renderizan texto sin traducir | Cada solicitud traduce lo que renderiza, con el texto y el contexto que envíes                                              | Traducción inmediata de publicaciones de usuarios, respuestas de soporte o resultados de IA |
| Proxy o superposición mediante script ([Weglot](https://weglot.com/technical-presentation/), [Transifex Live](https://help.transifex.com/en/articles/6244596-introduction-to-transifex-live)) | Un proxy sirve HTML traducido; una superposición reemplaza el texto en el navegador                    | Del servicio de entrega del proveedor, sujeto al almacenamiento en caché      | Se edita en el panel de control del proveedor y luego se sirve a través de su capa de entrega                               | Sitios terminados que no quieres modificar; sitios de marketing                             |

Usa la inclusión en el paquete build-time cuando quieras que el código y los textos se revisen y se lancen juntos. Elige una CDN cuando los revisores deban publicar correcciones de textos entre lanzamientos de la app. Por ejemplo, corregir la etiqueta de un botón en alemán puede actualizar una app que carga las traducciones desde una CDN sin necesidad de recompilarla; en cambio, añadir un botón nuevo sigue requiriendo desplegar el componente. Generar traducciones en el momento de la solicitud añade latencia frente a leer una traducción ya terminada, así que mantén los textos conocidos de la interfaz en la ruta pretraducida.

## ¿Qué enfoque es mejor para el SEO?

Asigna a cada idioma una URL estable y rastreable, como `/es/pricing`, y devuelve el contenido traducido y los metadatos en esa URL. Las páginas server-rendered y las generadas estáticamente pueden hacerlo con traducciones empaquetadas o cargadas desde una CDN; un proxy con subdirectorios por idioma también lo permite. Google [recomienda usar URL independientes para cada versión de idioma](https://developers.google.com/search/docs/specialty/international/managing-multi-regional-sites). Aunque puede [renderizar JavaScript](https://developers.google.com/search/docs/crawling-indexing/javascript/javascript-seo-basics), una superposición que cambia el idioma de una misma URL solo cuando el visitante hace clic en un selector de idioma no ofrece páginas independientes por idioma que se puedan rastrear. La [guía de SEO multilingüe para Next.js](/kb/multilingual-nextjs-seo) trata hreflang y los metadatos.

## ¿Cuál es la diferencia entre la i18n renderizada en el edge y un proxy de traducción?

Con la i18n renderizada en el edge, tu aplicación renderiza HTML traducido en un entorno de ejecución edge con sus propias rutas y traducciones. El middleware de configuración regional por sí solo no hace que la página se renderice en el edge: el entorno de ejecución del renderizado depende de otra decisión, la del framework y el alojamiento. Tú controlas las rutas localizadas, el contenido renderizado y el almacenamiento en caché.

Un proxy traduce la salida en lugar del código de origen. El [proxy inverso de Weglot](https://weglot.com/technical-presentation/) traduce cada página en su camino hacia el visitante, almacena en caché las solicitudes repetidas y detecta el contenido nuevo a medida que se sirve; la redacción se edita desde su panel de control. La [guía para sitios web](/kb/make-website-multilingual) explica la configuración inicial. Funciona con un origen que devuelve su contenido como HTML, ya sea estático o server-rendered. El texto generado únicamente por JavaScript en el navegador no aparece en esa respuesta del origen. Un proxy ve la estructura HTML renderizada; los componentes del código fuente y las notas de contexto del desarrollador no la acompañan automáticamente. La [comparación con Weglot](/kb/general-translation-vs-weglot) analiza las ventajas y desventajas.

## ¿Cómo entrego traducciones en una aplicación de Next.js con SSG, ISR o SSR?

Genera las traducciones antes de la compilación y todos los modos de renderizado podrán usarlas. Con `gt-next` de General Translation, ejecuta [`npx gt translate`](/docs/cli/reference/commands/translate) antes de `next build`. Con el renderizado server-side (SSR), una edición publicada en la CDN puede aparecer en un nuevo renderizado una vez que se actualicen las cachés de traducciones. Con la Generación de Sitios Estáticos (SSG), el texto traducido queda incorporado en un HTML que se mantiene hasta que se vuelva a compilar o se revalide. Con la regeneración estática incremental (ISR), [la revalidación regenera ese HTML](https://nextjs.org/docs/app/guides/incremental-static-regeneration), que reflejará una corrección de redacción una vez que la caché de traducciones también se haya actualizado. Una exportación completamente estática requiere una nueva compilación.

Para renderizar previamente una ruta por cada configuración regional en el App Router, mueve tus rutas a `app/[locale]` con el middleware de configuración regional de `gt-next` y, después, devuelve todas las configuraciones regionales desde `generateStaticParams`:

```tsx title="app/[locale]/page.tsx"
import { getLocales, T } from 'gt-next';

export function generateStaticParams() {
  return getLocales().map((locale) => ({ locale }));
}

export default function HomePage() {
  return <T>Welcome to our site</T>;
}
```

Esto da por hecho que ya tienes la configuración inicial del plugin y del proveedor descrita en el Inicio rápido de Next.js, un archivo `getLocale.ts` en la raíz que lee el parámetro `locale` de la raíz y un archivo `getRegion.ts` que devuelve `undefined`. Consulta la [guía de generación estática con App Router](/docs/react/nextjs/app-router-static-site-generation) para ver las versiones de Next.js y los archivos compatibles. Renderizar previamente rutas en un despliegue de Next.js no es lo mismo que usar `output: 'export'`, que además requiere la configuración de exportación estática que se describe en la guía.

## ¿Cómo traduzco contenido que solo existe en tiempo de ejecución?

Si necesitas traducir una nota en el momento en que un visitante la abre, el componente [`<Tx>`](/docs/react/nextjs/reference/components/tx) y la función [`tx`](/docs/react/nextjs/reference/functions/tx) de General Translation llaman a la API de traducción desde los componentes de servidor del App Router de Next.js. En este ejemplo se da por hecho que el enrutamiento por configuración regional ya está configurado y que `getNote` carga la nota:

```tsx title="app/[locale]/notes/[id]/page.tsx"
import { Tx } from 'gt-next/server';
import { getNote } from '@/lib/notes';

export default async function NotePage({
  params,
}: {
  params: Promise<{ id: string }>;
}) {
  const { id } = await params;
  const note = await getNote(id);
  return <Tx context="A note written by a user">{note.body}</Tx>;
}
```

En producción, asigna a `GT_API_KEY` en el servidor una clave de proyecto que tenga habilitada la opción **Runtime translation**, y no la expongas nunca en el navegador ([credenciales de producción](/docs/react/nextjs/config#credentials)). La traducción en el momento de la solicitud se factura aparte de la traducción en tiempo de compilación; consulta las [tarifas de uso](https://generaltranslation.com/pricing/usage). Fuera de los componentes de servidor de Next.js, por ejemplo en una API de Express, la función [`tx`](/docs/node/reference/functions/tx) de `gt-node` hace lo mismo con las cadenas.

## ¿Cómo entrega General Translation las traducciones?

General Translation genera las traducciones con su CLI y, después, tu aplicación las lee desde uno de estos dos lugares:

* **Archivos locales.** Define una ruta de salida en `gt.config.json`, ejecuta [`npx gt translate`](/docs/cli/reference/commands/translate) antes de la compilación y proporciona una función [`loadTranslations`](/docs/react/reference/functions/load-translations) que importe cada configuración regional. Al renderizar esas traducciones empaquetadas no se realiza ninguna solicitud a General Translation. [`gt init`](/docs/cli/reference/commands/init) recomienda esta configuración (**Save locally**), y es la única opción disponible para `gt-vue`.
* **La CDN de General Translation**, en los SDK de React y Next.js. Habilita la CDN en la configuración de tu proyecto, ejecuta [`npx gt translate --publish`](/docs/cli/reference/commands/translate) y proporciona al SDK tu [`projectId`](/docs/react/reference/config#project-id) sin un cargador local. Si no hay ningún cargador local configurado, el SDK carga las traducciones desde la CDN de forma predeterminada. La CLI registra la versión de origen que debe cargar la compilación. Las ediciones publicadas en esa versión pueden llegar a nuevos renderizados en cuanto se actualicen las cachés, sin necesidad de desplegar código nuevo de la aplicación. El contenido nuevo sigue publicándose con el despliegue que lo incorpora, y el HTML estático se rige por las reglas de recompilación o revalidación descritas anteriormente. La entrega por CDN [es gratuita](https://generaltranslation.com/pricing/usage).

Pasar de archivos locales a la CDN, o viceversa, solo requiere un cambio de configuración; tus componentes siguen igual. La [guía de almacenamiento de traducciones](/docs/react/guides/storing-translations) muestra el cargador para cada framework de React.

## Conclusiones clave

* Genera las traducciones conocidas de la app antes de desplegar. Inclúyelas en el paquete del lanzamiento o cárgalas desde una CDN si necesitas que las correcciones de redacción lleguen a los nuevos renderizados entre un lanzamiento y otro.
* Traduce el contenido nuevo al publicarlo, en un trabajo en segundo plano o bajo demanda, según cuándo lo necesiten los usuarios. Mantén las claves de la API de traducción en el servidor.
* Un proxy añade idiomas sin modificar el código, pero traduce el HTML renderizado y depende del proveedor en cada vista de una página traducida.
* General Translation sirve los mismos componentes [`<T>`](/docs/react/reference/components/t) desde archivos locales o desde su CDN, y añade [`<Tx>`](/docs/react/nextjs/reference/components/tx) para el contenido en tiempo de solicitud. Empieza con el [Inicio rápido de Next.js](/docs/react/nextjs-quickstart).

## Related questions

- [¿Cómo hago que un sitio web sea multilingüe?](https://generaltranslation.com/es/kb/make-website-multilingual.mdx): Elige dónde se alojarán las traducciones (en un proxy, un plugin de CMS, un creador de sitios web o tu propio código) y después asigna a cada idioma su propia URL, tal como recomienda Google. Traduce las páginas completas, además de los títulos y las metadescripciones, vincula las versiones con hreflang y ofrece un selector de idioma en lugar de redirigir automáticamente a los visitantes.
- [¿Cómo configuro el SEO de una aplicación de Next.js multilingüe?](https://generaltranslation.com/es/kb/multilingual-nextjs-seo.mdx): Asigna a cada idioma su propia URL con prefijo, como /en/about y /es/about, y luego publica html lang, una URL canónica autorreferente, versiones alternativas hreflang con x-default, un título y una descripción traducidos, y una entrada en el mapa del sitio para cada idioma publicado. Marca con noindex las versiones no publicadas. gt-next de General Translation dirige cada idioma a su propia URL y traduce los títulos con getGT.
- [¿Cuál es la mejor herramienta de localización continua para equipos que publican a diario?](https://generaltranslation.com/es/kb/best-continuous-localization-tools.mdx): Elige General Translation para traducir los textos nuevos antes de cada compilación, con contexto procedente del JSX marcado y de la terminología compartida del producto. Tu equipo revisa y corrige la redacción en el panel de control, y Locadex abre pull requests para marcar los nuevos textos de la UI para su traducción. Puedes adoptar este flujo de trabajo sin renunciar a tu configuración actual de i18next o next-intl.
- [Alternativas a Weglot: General Translation vs. Weglot](https://generaltranslation.com/es/kb/general-translation-vs-weglot.mdx): Weglot es un servicio de traducción de sitios web que traduce páginas renderizadas mediante plugins, un fragmento de código o un proxy, y Weglot 2.0 incorpora flujos de trabajo de traducción de archivos JSON en GitHub. General Translation es una plataforma de localización que combina la internacionalización del código fuente, la traducción de archivos, el contexto compartido, la revisión en el panel de control y el enrutamiento por configuración regional.
- [Redirecciones de idioma y SEO: ¿URL, cookie o Accept-Language?](https://generaltranslation.com/es/kb/locale-routing-seo.mdx): Deja que la URL determine el idioma de cada página que quieras indexar, porque Googlebot no envía la cabecera Accept-Language y rastrea sobre todo desde direcciones de EE. UU. Recurre a la preferencia guardada en una cookie y, en su defecto, a Accept-Language solo para decidir adónde redirige una raíz neutral como /, mediante una redirección temporal 302 o 307.

## Previous and next questions

- Previous question: [Agente de programación con IA vs. flujo de traducción: ¿cuál debería automatizar tu localización?](https://generaltranslation.com/es/kb/ai-coding-agent-vs-translation-pipeline.mdx)

## Sitemap

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