# General Translation Platform: translateMany
URL: https://generaltranslation.com/es/docs/platform/core/reference/gt-class-methods/translation/translate-many.mdx
---

title: translateMany
description: Traduce múltiples cadenas o entradas de contenido estructurado en una sola solicitud. Referencia de la API para translateMany.

---

Traduce múltiples entradas de contenido en una sola solicitud a la API de General Translation. Úsalo para la traducción por lotes: es más eficiente que realizar muchas llamadas individuales a [`translate`](/docs/platform/core/reference/gt-class-methods/translation/translate).

## Descripción general [#overview]

Llama a `translateMany` en una instancia de [`GT`](/docs/platform/core/reference/gt-class/constructor) ya configurada con una colección de entradas y una string de configuración regional de destino (forma abreviada) o un objeto de opciones. Acepta las entradas como una lista o como un registro indexado por hash, y devuelve los resultados con la misma forma.

```typescript
const gt = new GT({ apiKey: 'your-api-key', projectId: 'your-project-id' });

const results = await gt.translateMany(
  ['Hello, world!', 'Welcome to our app', 'Click here to continue'],
  'es'
);
```

Firma:

```typescript
// Sobrecarga 1: lista de entradas
translateMany(
  sources: TranslateManyEntry[],
  options: string | TranslateOptions,
  timeout?: number
): Promise<TranslateManyResult>

// Sobrecarga 2: record de entradas indexadas por hash
translateMany(
  sources: Record<string, TranslateManyEntry>,
  options: string | TranslateOptions,
  timeout?: number
): Promise<Record<string, TranslationResult>>
```

*Nota: `translateMany` requiere una `apiKey` (o `devApiKey`) y `projectId` en la instancia de GT.*

## Cómo funciona [#how-it-works]

* **lista vs. registro.** Con un lista, las entradas se procesan internamente como hashes y los resultados se devuelven en el orden de entrada. Con un registro, las claves se tratan como hashes y la respuesta es un registro con las mismas claves.
* **Resultados independientes.** Los fallos de traducción individuales no detienen el procesamiento por lotes: cada resultado informa por separado si tuvo éxito o falló, por lo que la compatibilidad con éxitos parciales es total.
* **Abreviatura de opciones.** Pasar una cadena para `options` es una abreviatura de `{ targetLocale: string }`, por lo que `gt.translateMany(['Hello'], 'es')` y `gt.translateMany(['Hello'], { targetLocale: 'es' })` son equivalentes.

## Parámetros [#parameters]

| Parámetro             | Descripción                                                             | Tipo                                                                                                                     | Opcional | Predeterminado |
| --------------------- | ----------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------ | -------- | -------------- |
| [`sources`](#sources) | Array o registro de entradas que se van a traducir.                     | [`TranslateManyEntry[] \| Record<string, TranslateManyEntry>`](/docs/platform/core/reference/types/translate-many-entry) | No       | —              |
| [`options`](#options) | Cadena de la configuración regional de destino o un objeto de opciones. | `string \| TranslateOptions`                                                                                             | No       | —              |
| [`timeout`](#timeout) | Tiempo de espera de la solicitud en milisegundos.                       | `number`                                                                                                                 | Sí       | —              |

### `sources` [#sources]

**Tipo** [`TranslateManyEntry[] \| Record<string, TranslateManyEntry>`](/docs/platform/core/reference/types/translate-many-entry) · **Obligatorio**

Las entradas que se deben traducir. Cada [`TranslateManyEntry`](/docs/platform/core/reference/types/translate-many-entry) es una string simple o un objeto con `source` (el [`Content`](/docs/platform/core/reference/types/content)) y `metadata` opcional (un [`EntryMetadata`](/docs/platform/core/reference/types/entry-metadata)):

```typescript
type TranslateManyEntry = string | { source: Content; metadata?: EntryMetadata };
```

Pasa una lista para recibir los resultados en el orden de entrada, o un registro con el hash como clave para recibir los resultados con las mismas claves.

### `options` [#options]

**Tipo** `string | TranslateOptions` · **Obligatorio**

Una cadena con la configuración regional de destino, como `'es'`, o un objeto de opciones:

```typescript
type TranslateOptions = {
  targetLocale: string; // configuración regional a la que traducir
  sourceLocale?: string; // anula el sourceLocale de la instancia
  modelProvider?: string; // sugerencia opcional de proveedor de modelo
};
```

### `timeout` [#timeout]

**Tipo** `number` · **Opcional**

Tiempo de espera de la solicitud en milisegundos. Si se omite, se usa el valor predeterminado de la instancia.

## Valor devuelto [#returns]

**Tipo** `Promise<TranslateManyResult> | Promise<Record<string, TranslationResult>>`

* La **entrada de lista** se resuelve como un [`TranslateManyResult`](/docs/platform/core/reference/types/translate-many-result) (una lista de objetos [`TranslationResult`](/docs/platform/core/reference/types/translation-result)), en el mismo orden que la entrada.
* La **entrada de tipo Record** se resuelve como un `Record<string, TranslationResult>`, indexado con los mismos hashes que la entrada.

Acota el tipo de cada resultado con `success` antes de leer su traducción.

## Ejemplos [#examples]

```typescript
// Lista de cadenas
const results = await gt.translateMany(['Home', 'About', 'Products', 'Contact'], 'fr');

results.forEach((result, index) => {
  if (result.success) {
    console.log(`Item ${index}: ${result.translation}`);
  } else {
    console.error(`Item ${index} failed: ${result.error}`);
  }
});
```

```typescript
// Array con metadatos por entrada
const results = await gt.translateMany(
  [
    { source: 'Hello, world!', metadata: { dataFormat: 'ICU' } },
    { source: 'Goodbye, world!' },
  ],
  { targetLocale: 'es' }
);
```

```typescript
// Record con clave hash — los resultados se devuelven bajo las mismas claves
const results = await gt.translateMany(
  {
    'greeting-hash': 'Hello, world!',
    'farewell-hash': 'Goodbye, world!',
  },
  'es'
);

console.log(results['greeting-hash'].translation);
```

## Notas [#notes]

* Traduce varias entradas en una sola solicitud a la API.
* Un fallo en una entrada no afecta a las demás.
* Los resultados mantienen el mismo orden que la lista de entrada, o las mismas claves que el registro de entrada.