# General Translation Platform: translateMany
URL: https://generaltranslation.com/fr/docs/platform/core/reference/gt-class-methods/translation/translate-many.mdx
---
title: translateMany
description: Traduire plusieurs chaînes ou entrées de contenu structurées en une seule requête. Référence de l’API pour translateMany.

---

Traduit plusieurs entrées de contenu dans une seule requête à l’API de General Translation. Utilisez-la pour la traduction par lots : c’est plus efficace que d’effectuer de nombreux appels individuels à [`translate`](/docs/platform/core/reference/gt-class-methods/translation/translate).

## Vue d’ensemble [#overview]

Appelez `translateMany` sur une instance configurée de [`GT`](/docs/platform/core/reference/gt-class/constructor) avec une collection d’entrées et soit une chaîne de caractères pour le paramètre régional cible (syntaxe abrégée), soit un objet d’options. Elle accepte les entrées sous la forme d’un tableau ou d’un record indexé par hachage, et renvoie les résultats dans le même format.

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

Signature :

```typescript
// Surcharge 1 : tableau d'entrées
translateMany(
  sources: TranslateManyEntry[],
  options: string | TranslateOptions,
  timeout?: number
): Promise<TranslateManyResult>

// Surcharge 2 : record d'entrées indexées par hachage
translateMany(
  sources: Record<string, TranslateManyEntry>,
  options: string | TranslateOptions,
  timeout?: number
): Promise<Record<string, TranslationResult>>
```

*Remarque : `translateMany` nécessite une `apiKey` (ou `devApiKey`) ainsi qu’un `projectId` sur l’instance GT.*

## Fonctionnement [#how-it-works]

* **Tableau ou record.** Avec un tableau, les entrées sont hachées en interne et les résultats sont renvoyés dans l&#39;ordre d&#39;entrée. Avec un record, les clés sont traitées comme des hachages et la réponse est un record avec les mêmes clés.
* **Résultats indépendants.** Un échec de traduction sur un élément n&#39;interrompt pas le traitement par lots — chaque résultat indique séparément une réussite ou un échec, ce qui prend entièrement en charge les réussites partielles.
* **Syntaxe abrégée des options.** Passer une string à `options` est une syntaxe abrégée pour `{ targetLocale: string }` ; `gt.translateMany(['Hello'], 'es')` et `gt.translateMany(['Hello'], { targetLocale: 'es' })` sont donc équivalents.

## Paramètres [#parameters]

| Paramètre             | Description                                             | Type                                                                                                                     | Facultatif | Par défaut |
| --------------------- | ------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------ | ---------- | ---------- |
| [`sources`](#sources) | Tableau ou record d’entrées à traduire.                  | [`TranslateManyEntry[] \| Record<string, TranslateManyEntry>`](/docs/platform/core/reference/types/translate-many-entry) | Non        | —          |
| [`options`](#options) | Chaîne du paramètre régional cible, ou objet d’options. | `string \| TranslateOptions`                                                                                             | Non        | —          |
| [`timeout`](#timeout) | Délai d’expiration de la requête en millisecondes.      | `number`                                                                                                                 | Oui        | —          |

### `sources` [#sources]

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

Les entrées à traduire. Chaque [`TranslateManyEntry`](/docs/platform/core/reference/types/translate-many-entry) est une simple chaîne, ou un objet avec `source` (le [`Content`](/docs/platform/core/reference/types/content)) et un `metadata` facultatif (un [`EntryMetadata`](/docs/platform/core/reference/types/entry-metadata)) :

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

Passez un tableau pour récupérer les résultats dans le même ordre que les entrées, ou un record dont les clés sont les hachages pour récupérer les résultats sous ces mêmes clés.

### `options` [#options]

**Type** `string | TranslateOptions` · **Obligatoire**

Une chaîne de caractères correspondant au paramètre régional cible, comme `'es'`, ou un objet d’options :

```typescript
type TranslateOptions = {
  targetLocale: string; // paramètre régional cible de la traduction
  sourceLocale?: string; // remplace le sourceLocale de l'instance
  modelProvider?: string; // indication facultative du fournisseur de modèle
};
```

### `timeout` [#timeout]

**Type** `number` · **Facultatif**

Délai d’expiration de la requête, en millisecondes. S’il n’est pas précisé, la valeur par défaut de l’instance est utilisée.

## Valeur de retour [#returns]

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

* Une **entrée de type tableau** se résout en [`TranslateManyResult`](/docs/platform/core/reference/types/translate-many-result) (un tableau d’objets [`TranslationResult`](/docs/platform/core/reference/types/translation-result)), dans le même ordre que l’entrée.
* Une **entrée de type `Record`** se résout en `Record<string, TranslationResult>`, avec les mêmes hachages comme clés que l’entrée.

Affinez le type de chaque résultat à l’aide de `success` avant de lire sa traduction.

## Exemples [#examples]

```typescript
// Tableau de strings
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
// Tableau avec métadonnées par entrée
const results = await gt.translateMany(
  [
    { source: 'Hello, world!', metadata: { dataFormat: 'ICU' } },
    { source: 'Goodbye, world!' },
  ],
  { targetLocale: 'es' }
);
```

```typescript
// Record indexé par hachage — les résultats sont renvoyés sous les mêmes clés
const results = await gt.translateMany(
  {
    'greeting-hash': 'Hello, world!',
    'farewell-hash': 'Goodbye, world!',
  },
  'es'
);

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

## Notes [#notes]

* Traduit plusieurs entrées en une seule requête API.
* Un échec sur une entrée n’affecte pas les autres.
* Les résultats conservent le même ordre que le tableau d’entrée, ou les mêmes clés que le record d’entrée.