# 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 contenidos en una sola solicitud a la API.
Está optimizado para el procesamiento por lotes y ofrece mejor rendimiento que 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: array de entradas

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

Devuelve un `TranslateManyResult` (un array de objetos `TranslationResult`) en el mismo orden de entrada.


### Sobrecarga 2: registro de entradas

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

Si se le proporciona un registro con claves hash, devuelve un registro con las mismas claves hash.


### Parámetros

<TypeTable
  type={{
  "sources": {
    type: 'TranslateManyEntry[] | Record<string, TranslateManyEntry>',
    description: 'Array o registro de entradas que se van a traducir.',
    optional: false,
  },
  "options": {
    type: 'string | TranslateOptions',
    description: 'Cadena de la configuración regional de destino (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 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` | array o registro de elementos `TranslateManyEntry`. Cada uno puede ser una cadena simple o un objeto con `source` y `metadata` opcional.                     |
| `options` | Una cadena de configuración regional de destino (por ejemplo, `'es'`) o un objeto de opciones con `targetLocale`, `sourceLocale` opcional y `modelProvider`. |
| `timeout` | Tiempo de espera opcional de la solicitud en milisegundos.                                                                                                   |

### Devuelve

* **Entrada de tipo array** → `Promise<TranslateManyResult>` (`TranslationResult[]`), en el mismo orden de entrada
* **Entrada de tipo registro** → `Promise<Record<string, TranslationResult>>`, con claves basadas en los mismos hashes

***

## Comportamiento

### array vs registro

* **array**: Los elementos se procesan internamente como hashes; los resultados se devuelven en el 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 hubo éxito o fallo
* Los escenarios de éxito parcial son totalmente compatibles

### Forma abreviada de las opciones

Puedes pasar una cadena como parámetro `options` como forma abreviada de `{ targetLocale: string }`:

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

***


## Ejemplos

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


### array con metadatos

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


### Registro (con clave 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
* Un fallo de traducción en una entrada no afecta a las demás
* Los resultados se mantienen en el mismo orden de entrada (`array`) o conservan las mismas claves (`registro`)

## Siguientes pasos

* Aprende sobre 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)