# generaltranslation: General Translation Core SDK: translateMany
URL: https://generaltranslation.com/es/docs/core/class/methods/translation/translate-many.mdx
---
title: translateMany
description: Referencia de la API del método translateMany de GT para traducciones por lotes
---

## Resumen

El método `translateMany` traduce de forma eficiente varios elementos de contenido en una sola solicitud a la API.
Está optimizado para el procesamiento por lotes y ofrece un rendimiento superior al de varias llamadas individuales a `translate`.

```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'
);
```

***


## Referencia

### Sobrecarga 1: arreglo de entradas

```typescript
translateMany(
  sources: TranslateManyEntry[],
  options: string | TranslateOptions,
  timeout?: number
): Promise<TranslateManyResult>
```

Devuelve un `TranslateManyResult` (un arreglo de objetos `TranslationResult`) en el mismo orden que la entrada.


### Sobrecarga 2: registro de entradas

```typescript
translateMany(
  sources: Record<string, TranslateManyEntry>,
  options: string | TranslateOptions,
  timeout?: number
): Promise<Record<string, TranslationResult>>
```

Cuando recibe un registro con claves hash, devuelve un registro con las mismas claves hash.


### Parámetros

<TypeTable
  type={{
  "sources": {
    type: 'TranslateManyEntry[] | Record<string, TranslateManyEntry>',
    description: 'Arreglo o registro de entradas para traducir.',
    optional: false,
  },
  "options": {
    type: 'string | TranslateOptions',
    description: 'Configuración regional de destino como cadena (forma abreviada) o un objeto de opciones.',
    optional: false,
  },
  "timeout?": {
    type: 'number',
    description: 'Tiempo de espera opcional de la solicitud en milisegundos.',
    optional: true,
  }
}}
/>

### TranslateManyEntry

Cada entrada puede ser una cadena simple o un objeto con el contenido de origen y metadatos opcionales:

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


### TranslateOptions

```typescript
type TranslateOptions = {
  targetLocale: string;
  sourceLocale?: string;
  modelProvider?: string;
};
```


### Descripción de los parámetros

| Parámetro | Descripción                                                                                                                                                 |
| --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `sources` | arreglo o registro de elementos `TranslateManyEntry`. Cada uno puede ser una cadena simple o un objeto con `source` y `metadata` opcional.                    |
| `options` | Una cadena con la configuración regional de destino (p. ej., `'es'`) o un objeto de opciones con `targetLocale`, `sourceLocale` opcional y `modelProvider`. |
| `timeout` | Tiempo de espera opcional de la solicitud, en milisegundos.                                                                                                 |

### Devuelve

* **Entrada como arreglo** → `Promise<TranslateManyResult>` (`TranslationResult[]`), en el mismo orden que la entrada
* **Entrada como registro** → `Promise<Record<string, TranslationResult>>`, indexado por los mismos hashes

***

## Comportamiento

### arreglo vs registro

* **arreglo**: Las entradas se convierten internamente en hashes; los resultados se devuelven en el mismo orden de entrada.
* **registro**: Las claves se tratan como hashes; la respuesta es un registro con las mismas claves.

### Estrategia de gestión de errores

* Los fallos de traducción individuales no detienen todo el lote
* Cada resultado indica de forma independiente si fue correcto o falló
* Se admite plenamente el éxito parcial

### Forma abreviada de `options`

Puedes pasar una cadena en el parámetro `options` como abreviatura de `{ targetLocale: string }`:

```typescript
// Estas son equivalentes:
await gt.translateMany(['Hello', 'Goodbye'], 'es');
await gt.translateMany(['Hello', 'Goodbye'], { targetLocale: 'es' });
```

***


## Ejemplos

### Arreglo de cadenas

```typescript
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}`);
  }
});
```


### Arreglo con metadatos

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


### Registro (indexado por hash)

```typescript
const results = await gt.translateMany(
  {
    'greeting-hash': 'Hello, world!',
    'farewell-hash': 'Goodbye, world!'
  },
  'es'
);

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

***


## Notas

* Traduce varios elementos en una sola solicitud a la API
* Los fallos de traducción en una entrada no afectan a las demás
* Los resultados mantienen el mismo orden que las entradas de entrada (array) o las mismas claves (registro)

## Siguientes pasos

* Aprende sobre las traducciones individuales con [translate](/docs/core/class/methods/translation/translate)
* Explora el [tipo TranslateManyEntry](/docs/core/types/Entry)
* Comprende la [estructura de TranslateManyResult](/docs/core/types/translate-many-result)