> ## Documentation Index
> Fetch the complete documentation index at: https://www.helius.dev/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Présentation et Tutoriel de getTransactionsForAddress

> Apprenez à interroger l'historique des transactions Solana avec un filtrage avancé, un tri bidirectionnel et une pagination efficace en utilisant cette méthode RPC exclusive à Helius.

## Aperçu

[`getTransactionsForAddress`](/docs/fr/api-reference/rpc/http/gettransactionsforaddress) est une méthode RPC exclusive à Helius qui renvoie l'historique des transactions d'une adresse avec un filtrage avancé, un tri flexible et une pagination efficace. Elle ne fait pas partie du standard RPC de Solana.

Contrairement à `getSignaturesForAddress`, qui retourne uniquement des signatures et ignore les comptes de jetons associés, `getTransactionsForAddress` peut retourner des données complètes sur les transactions, y compris l'activité du compte de jetons associé (ATA) d'un portefeuille, en un seul appel. Cela en fait le chemin le plus rapide vers un historique complet d'adresse pour le remplissage rétroactif, l'indexation et l'analyse.

Cette méthode retourne jusqu'à 1 000 transactions complètes par appel.

<CardGroup cols={2}>
  <Card title="Tri flexible" icon="arrows-up-down">
    Triez chronologiquement (du plus ancien au plus récent) ou inversement (du plus récent au plus ancien).
  </Card>

  <Card title="Filtrage avancé" icon="filter">
    Filtrez par plages horaires, créneaux, signatures, statut et transferts de jetons.
  </Card>

  <Card title="Données transactionnelles complètes" icon="database">
    Obtenez des détails complets sur les transactions en un seul appel, sans besoin de suivi getTransaction.
  </Card>

  <Card title="Comptes de jetons" icon="layer-group">
    Incluez les transactions pour les comptes de jetons associés à une adresse.
  </Card>
</CardGroup>

## Quand l'utiliser

Utilisez `getTransactionsForAddress` lorsque vous avez besoin de :

* Historique complet des jetons de portefeuille, y compris les comptes de jetons associés
* Un remplissage rétroactif rapide en un seul appel pour un indexeur ou un pipeline de données
* Analyse et rapport de transactions basés sur le temps ou les créneaux
* Filtrage par statut pour garder uniquement les transactions réussies ou échouées
* Relecture historique chronologique (tri du plus ancien au plus récent)
* Analyse de lancement de jetons : premières transactions de frappe et premiers détenteurs
* Historique de financement de portefeuille et découverte de contreparties
* Rapports de conformité et d'audit pour une période spécifique

Pour un historique analysé, axé uniquement sur les transferts (paiements, réconciliation des soldes), utilisez [`getTransfersByAddress`](/docs/fr/rpc/gettransfersbyaddress) à la place.

### Support réseau

| Réseau  | Pris en charge | Période de rétention |
| ------- | -------------- | -------------------- |
| Mainnet | Oui            | Illimité             |
| Devnet  | Oui            | 2 semaines           |
| Testnet | Non            | N/A                  |

## Démarrage rapide

<Steps>
  <Step title="Obtenez votre clé API">
    Obtenez votre clé API depuis le [Tableau de bord Helius](https://dashboard.helius.dev/api-keys).
  </Step>

  <Step title="Interrogez avec des fonctionnalités avancées">
    Obtenez toutes les transactions réussies pour un portefeuille entre deux dates, triées chronologiquement :

    ```javascript theme={"system"}
    // Get successful transactions between Jan 1-31, 2025 in chronological order
    const response = await fetch('https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        jsonrpc: '2.0',
        id: 1,
        method: 'getTransactionsForAddress',
        params: [
          'YOUR_ADDRESS_HERE',
          {
            transactionDetails: 'full',
            sortOrder: 'asc',
            limit: 1000,
            filters: {
              blockTime: {
                gte: 1735689600,   // Jan 1, 2025
                lt: 1738368000     // Before Feb 1, 2025
              },
              status: 'succeeded',  // Only successful transactions
              tokenAccounts: 'balanceChanged' // Include associated token accounts
            }
          }
        ]
      })
    });

    const data = await response.json();
    console.log('Successful transactions in January:', data.result.data);
    ```
  </Step>

  <Step title="Comprendre les paramètres">
    Cet exemple montre les caractéristiques clés :

    * **transactionDetails** : définissez sur `'full'` pour obtenir des données de transaction complètes en un seul appel
    * **sortOrder** : utilisez `'asc'` pour un ordre chronologique (du plus ancien au plus récent) ou `'desc'` pour le plus récent en premier
    * **filters.blockTime** : définissez des plages horaires avec `gte` (supérieur ou égal) et `lte` (inférieur ou égal)
    * **filters.status** : filtrez uniquement `'succeeded'` ou `'failed'` transactions
    * **filters.tokenAccounts** : incluez les transferts, frappes et brûlures pour les comptes de jetons associés
  </Step>
</Steps>

## Paramètres de requête

<ParamField body="address" type="string" required>
  Clé publique encodée en Base-58 du compte pour lequel interroger l'historique des transactions
</ParamField>

<ParamField body="transactionDetails" type="string" default="signatures">
  Niveau de détail de transaction à retourner :

  * `signatures` : Infos de signature de base (plus rapide)
  * `full` : Données complètes de transaction (élimine le besoin pour les appels getTransaction, supporte une limite jusqu'à 1 000)
</ParamField>

<ParamField body="sortOrder" type="string" default="desc">
  Ordre de tri des résultats :

  * `desc` : Le plus récent en premier (par défaut)
  * `asc` : Le plus ancien en premier (chronologique, idéal pour l'analyse historique)
</ParamField>

<ParamField body="limit" type="number" default="1000">
  Nombre maximum de transactions à retourner :

  * Jusqu'à 1000 lorsque `transactionDetails: "signatures"`
  * Jusqu'à 1000 lorsque `transactionDetails: "full"`
</ParamField>

<ParamField body="paginationToken" type="string">
  Jeton de pagination de la réponse précédente (format : `"slot:position"`)
</ParamField>

<ParamField body="commitment" type="string" default="finalized">
  Niveau d'engagement : `finalized` ou `confirmed`. L'engagement `processed` n'est pas pris en charge.
</ParamField>

<ParamField body="filters" type="object">
  Options de filtrage avancées pour affiner les résultats.
</ParamField>

<ParamField body="filters.slot" type="object">
  Filtrez par numéro de créneau à l'aide d'opérateurs de comparaison : `gte`, `gt`, `lte`, `lt`

  Exemple : `{ "slot": { "gte": 1000, "lte": 2000 } }`
</ParamField>

<ParamField body="filters.blockTime" type="object">
  Filtrez par horodatage Unix avec des opérateurs de comparaison : `gte`, `gt`, `lte`, `lt`, `eq`

  Exemple : `{ "blockTime": { "gte": 1640995200, "lte": 1641081600 } }`
</ParamField>

<ParamField body="filters.signature" type="object">
  Filtrez par signature de transaction à l'aide d'opérateurs de comparaison : `gte`, `gt`, `lte`, `lt`

  Exemple : `{ "signature": { "lt": "SIGNATURE_STRING" } }`
</ParamField>

<ParamField body="filters.status" type="string">
  Filtrez par statut de réussite/échec des transactions :

  * `succeeded` : Uniquement les transactions réussies
  * `failed` : Uniquement les transactions échouées
  * `any` : Les deux réussies et échouées (par défaut)

  Exemple : `{ "status": "succeeded" }`
</ParamField>

<ParamField body="filters.tokenAccounts" type="string" default="none">
  Filtrez les transactions pour les comptes de jetons associés :

  * `none` : Retournez uniquement les transactions qui font référence à l'adresse fournie (par défaut)
  * `balanceChanged` : Retournez les transactions qui font référence à l'adresse fournie ou modifient le solde d'un compte de jetons détenu par l'adresse fournie (recommandé)
  * `all` : Retournez les transactions qui font référence à l'adresse fournie ou à tout compte de jetons détenu par l'adresse fournie

  Exemple : `{ "tokenAccounts": "balanceChanged" }`
</ParamField>

<ParamField body="filters.tokenTransfer" type="object">
  Filtrez pour les transactions où l'adresse interrogée a participé à un transfert de jetons correspondant à une contrepartie, une direction, une frappe ou une plage de montants brute. Tous les champs sont optionnels et combinés par AND.

  Exemple : `{ "tokenTransfer": { "direction": "in", "mint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v" } }`
</ParamField>

<ParamField body="filters.tokenTransfer.with" type="string">
  Adresse de contrepartie. Correspond aux transferts dont l'autre côté est cette adresse.
</ParamField>

<ParamField body="filters.tokenTransfer.direction" type="string" default="any">
  Filtrez par direction du transfert par rapport à l'adresse interrogée :

  * `in` : Transferts reçus par l'adresse interrogée
  * `out` : Transferts envoyés par l'adresse interrogée
  * `any` : Transferts entrants et sortants
</ParamField>

<ParamField body="filters.tokenTransfer.mint" type="string">
  Frappe de jeton à filtrer.
</ParamField>

<ParamField body="filters.tokenTransfer.amount" type="object">
  Comparaison de montant en utilisant le montant brut sur la chaîne, et non le montant ajusté à l'interface utilisateur ou aux décimales. Supporte `gt`, `gte`, `lt`, et `lte`.
</ParamField>

<ParamField body="encoding" type="string">
  Format d'encodage pour les données de transaction (s'applique uniquement lorsque `transactionDetails: "full"`). Idem que `getTransaction` API. Options : `json`, `jsonParsed`, `base64`, `base58`
</ParamField>

<ParamField body="maxSupportedTransactionVersion" type="number">
  Définissez la version de transaction maximale à retourner. Si omis, seules les transactions héritées seront retournées. Définissez sur `1` pour inclure les transactions héritées, v0 et v1.
</ParamField>

<ParamField body="minContextSlot" type="number">
  Le créneau minimum auquel la requête peut être évaluée
</ParamField>

### Métrique

Les réponses réussies sont mesurées en fonction de ce qui est retourné :

| Type de réponse         | Crédits                                                                                          |
| ----------------------- | ------------------------------------------------------------------------------------------------ |
| Transactions complètes  | 10 crédits par 100 transactions retournées, arrondi à l'entier supérieur ; minimum de 10 crédits |
| Signatures uniquement   | 10 crédits forfaitaires, quel que soit le nombre                                                 |
| Réponses d'API échouées | Gratuit                                                                                          |

## Réponse

La forme de la réponse dépend de `transactionDetails`. Le mode signatures renvoie des enregistrements de signatures légers ; le mode complet renvoie des objets complets de transaction et de métadonnées.

<Tabs>
  <Tab title="Réponse Signatures">
    ```json theme={"system"}
    {
      "jsonrpc": "2.0",
      "id": 1,
      "result": {
        "data": [
          {
            "signature": "5h6xBEauJ3PK6SWCZ1PGjBvj8vDdWG3KpwATGy1ARAXFSDwt8GFXM7W5Ncn16wmqokgpiKRLuS83KUxyZyv2sUYv",
            "slot": 1054,
            "transactionIndex": 42,
            "err": null,
            "memo": null,
            "blockTime": 1641038400,
            "confirmationStatus": "finalized"
          }
        ],
        "paginationToken": "1055:5"
      }
    }
    ```
  </Tab>

  <Tab title="Réponse Transaction Complète">
    ```json theme={"system"}
    {
      "jsonrpc": "2.0",
      "id": 1,
      "result": {
        "data": [
          {
            "slot": 1054,
            "transactionIndex": 42,
            "blockTime": 1641038400,
            "transaction": {
              "signatures": ["5h6xBEauJ3PK6SWCZ1PGjBvj8vDdWG3KpwATGy1ARAXFSDwt8GFXM7W5Ncn16wmqokgpiKRLuS83KUxyZyv2sUYv"],
              "message": {
                "accountKeys": ["...", "..."],
                "instructions": [...],
                // Complete transaction structure
              }
            },
            "meta": {
              "err": null,
              "fee": 5000,
              "preBalances": [1000000, 2000000],
              "postBalances": [999995000, 2000000],
              "preTokenBalances": [
                {
                  "accountIndex": 1,
                  "mint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
                  "owner": "...",
                  "programId": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
                  "uiTokenAmount": {
                    "amount": "1500000",
                    "decimals": 6,
                    "uiAmount": 1.5,
                    "uiAmountString": "1.5"
                  }
                }
              ],
              "postTokenBalances": [
                {
                  "accountIndex": 1,
                  "mint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
                  "owner": "...",
                  "programId": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
                  "uiTokenAmount": {
                    "amount": "500000",
                    "decimals": 6,
                    "uiAmount": 0.5,
                    "uiAmountString": "0.5"
                  }
                }
              ],
              "innerInstructions": [...],
              "logMessages": [...],
              "computeUnitsConsumed": 2100
              // Complete metadata — same shape as getTransaction
            }
          }
        ],
        "paginationToken": "1055:5"
      }
    }
    ```
  </Tab>
</Tabs>

### Champs de réponse

| Champ                | Type           | Description                                                                                                                                                                                                                                                     |
| -------------------- | -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `signature`          | string         | Signature de transaction (encodée en base-58). Uniquement en mode signatures.                                                                                                                                                                                   |
| `slot`               | number         | Le créneau contenant le bloc avec cette transaction.                                                                                                                                                                                                            |
| `transactionIndex`   | number         | L'index zéro de la transaction dans son bloc. Utile pour le classement des transactions et la reconstruction de blocs.                                                                                                                                          |
| `blockTime`          | number \| null | Heure de production estimée en horodatage Unix (secondes depuis l'époque).                                                                                                                                                                                      |
| `err`                | object \| null | Erreur si la transaction a échoué, null si elle a réussi. Uniquement en mode signatures.                                                                                                                                                                        |
| `memo`               | string \| null | Mémo associé à la transaction. Uniquement en mode signatures.                                                                                                                                                                                                   |
| `confirmationStatus` | string         | Statut de confirmation du cluster de la transaction. Uniquement en mode signatures.                                                                                                                                                                             |
| `transaction`        | object         | Données complètes de transaction. Uniquement en mode complet.                                                                                                                                                                                                   |
| `meta`               | object         | Métadonnées de statut de transaction — même forme que `getTransaction`, incluant `err`, `fee`, `preBalances`/`postBalances`, `preTokenBalances`/`postTokenBalances`, `innerInstructions`, `logMessages`, et `computeUnitsConsumed`. Uniquement en mode complet. |
| `paginationToken`    | string \| null | Jeton pour récupérer la page suivante, ou null s'il n'y a plus de résultats.                                                                                                                                                                                    |

Le champ `transactionIndex` est exclusif à `getTransactionsForAddress`. D'autres points de terminaison similaires comme `getSignaturesForAddress`, `getTransaction`, et `getTransactions` n'incluent pas ce champ.

En mode complet, `meta` est l'objet de métadonnées de transaction complet — identique en forme à ce que `getTransaction` retourne. Il inclut `preTokenBalances` et `postTokenBalances`, vous pouvez donc calculer les changements de solde des jetons (par exemple, pour détecter les échanges) directement à partir de la réponse sans appels de suivi.

## Filtres

Vous pouvez utiliser des opérateurs de comparaison pour `slot`, `blockTime`, et `signature`, plus les filtres spéciaux `status`, `tokenAccounts`, et `tokenTransfer`. La combinaison de plusieurs filtres réduit le résultat à leur intersection.

### Opérateurs de comparaison

Ces opérateurs fonctionnent comme des requêtes de base de données pour vous donner un contrôle précis sur votre plage de données.

| Opérateur | Nom complet           | Description                                                    | Exemple                         |
| --------- | --------------------- | -------------------------------------------------------------- | ------------------------------- |
| `gte`     | Supérieur ou égal     | Inclure les valeurs ≥ valeur spécifiée                         | `slot: { gte: 100 }`            |
| `gt`      | Strictement supérieur | Inclure les valeurs > valeur spécifiée                         | `blockTime: { gt: 1641081600 }` |
| `lte`     | Inférieur ou égal     | Inclure les valeurs ≤ valeur spécifiée                         | `slot: { lte: 2000 }`           |
| `lt`      | Strictement inférieur | Inclure les valeurs \< valeur spécifiée                        | `blockTime: { lt: 1641168000 }` |
| `eq`      | Égal                  | Inclure les valeurs égales exactement (uniquement `blockTime`) | `blockTime: { eq: 1641081600 }` |

### Filtres énumérés

| Filtre          | Description                                                  | Valeurs                            |
| --------------- | ------------------------------------------------------------ | ---------------------------------- |
| `status`        | Filtrer les transactions par réussite/échec                  | `succeeded`, `failed`, ou `any`    |
| `tokenAccounts` | Filtrer les transactions pour les comptes de jetons associés | `none`, `balanceChanged`, ou `all` |

Exemples de filtres combinés :

```javascript theme={"system"}
// Time range with successful transactions only
"filters": {
  "blockTime": {
    "gte": 1640995200,
    "lte": 1641081600
  },
  "status": "succeeded"
}

// Slot range
"filters": {
  "slot": {
    "gte": 1000,
    "lte": 2000
  }
}

// Only failed transactions
"filters": {
  "status": "failed"
}
```

### Comptes de jetons associés

Sur Solana, un portefeuille ne détient pas directement des jetons. Au lieu de cela, le portefeuille possède des comptes de jetons, et ces comptes de jetons détiennent les jetons. Lorsque quelqu'un vous envoie de l'USDC, il va sur votre compte de jetons USDC, pas sur l'adresse principale de votre portefeuille.

Cette méthode est unique car elle peut interroger **l'historique complet des jetons**, y compris les comptes de jetons associés d'un portefeuille (ATAs). Les méthodes RPC natives telles que `getSignaturesForAddress` n'incluent pas les ATAs.

Le filtre `tokenAccounts` contrôle ce comportement :

* **`none`** (par défaut) : Retourne uniquement les transactions qui font référence directement à l'adresse du portefeuille. Utilisez ceci lorsque vous vous intéressez uniquement aux interactions directes avec le portefeuille.
* **`balanceChanged`** (recommandé) : Retourne les transactions qui font référence à l'adresse du portefeuille ou modifient le solde d'un compte de jetons détenu par le portefeuille. Cela filtre le spam et les opérations non liées telles que les collectes de frais ou les délégations, vous donnant une vue claire des activités pertinentes du portefeuille.
* **`all`** : Retourne toutes les transactions qui font référence à l'adresse du portefeuille ou à tout compte de jetons détenu par le portefeuille.

Le filtre `tokenAccounts` ne prend pas en charge les transactions antérieures à décembre 2022. Il dépend des métadonnées de transfert de jetons introduites à Solana sur le créneau 111,491,819. Pour couvrir les activités antérieures, consultez la [solution de contournement des comptes de jetons historiques](#limitations-et-cas-particuliers).

### Filtre de transfert de jetons

Le filtre `tokenTransfer` restreint les résultats aux transactions où l'adresse interrogée a participé à un transfert de jetons correspondant à des critères spécifiques : une contrepartie particulière, une frappe, une direction ou une plage de montants.

Utilisez-le pour répondre à des questions comme :

* Quand ce portefeuille a-t-il reçu de l'USDC d'une contrepartie spécifique ?
* Affichez chaque transfert sortant supérieur à 1 000 jetons.
* Quand ce portefeuille a-t-il déjà touché une frappe spécifique ?

Le filtre est un champ optionnel à l'intérieur de l'objet `filters` de la configuration de la requête :

```json theme={"system"}
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getTransactionsForAddress",
  "params": [
    "<address>",
    {
      "filters": {
        "tokenTransfer": {}
      }
    }
  ]
}
```

Tous les champs à l'intérieur de `tokenTransfer` sont optionnels. La combinaison de plusieurs champs est traitée comme AND.

| Champ       | Type                         | Par défaut | Description                                                                                                                          |
| ----------- | ---------------------------- | ---------- | ------------------------------------------------------------------------------------------------------------------------------------ |
| `with`      | string (clé publique)        | -          | Adresse de contrepartie. Correspond aux transferts dont l'autre côté est cette adresse.                                              |
| `direction` | `"in"` \| `"out"` \| `"any"` | `"any"`    | Si l'adresse interrogée a reçu, envoyé, ou les deux.                                                                                 |
| `mint`      | string (clé publique)        | -          | Frappe de jeton à filtrer.                                                                                                           |
| `amount`    | object                       | -          | Comparaison de montants. Utilise le montant brut sur la chaîne, et non le montant ajusté à l'interface utilisateur ou aux décimales. |

Opérateurs de plage de montants :

| Opérateur | Signification         |
| --------- | --------------------- |
| `gt`      | Strictement supérieur |
| `gte`     | Supérieur ou égal     |
| `lt`      | Strictement inférieur |
| `lte`     | Inférieur ou égal     |

Vous pouvez combiner les opérateurs de montants, comme `{ "gte": 1000000, "lte": 5000000 }` pour une plage fermée. `tokenTransfer` se compose avec les autres filtres de niveau supérieur (`slot`, `blockTime`, `status`, et `tokenAccounts`); le résultat final est l'intersection.

## Exemples

### Analytique basée sur le temps

Générez des rapports mensuels de transactions :

```javascript theme={"system"}
// Get all successful transactions for January 2025
const startTime = Math.floor(new Date('2025-01-01').getTime() / 1000);
const endTime = Math.floor(new Date('2025-02-01').getTime() / 1000);

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getTransactionsForAddress",
  "params": [
    "WALLET_OR_PROGRAM_ADDRESS",
    {
      "transactionDetails": "signatures",
      "filters": {
        "blockTime": {
          "gte": startTime,
          "lt": endTime
        },
        "status": "succeeded"
      },
      "limit": 1000
    }
  ]
}
```

Processus pour l'analytique :

```javascript theme={"system"}
// Calculate daily transaction volume
const dailyStats = {};
response.result.data.forEach(tx => {
  const date = new Date(tx.blockTime * 1000).toISOString().split('T')[0];
  dailyStats[date] = (dailyStats[date] || 0) + 1;
});

console.log('Daily Transaction Counts:', dailyStats);
```

### Création de frappe de jetons

Trouvez la transaction de création de frappe pour un jeton spécifique :

```javascript theme={"system"}
{
  "jsonrpc": "2.0",
  "id": "find-first-mints",
  "method": "getTransactionsForAddress",
  "params": [
    MINT_ADDRESS, // Token mint address
    {
      "encoding": "jsonParsed",
      "maxSupportedTransactionVersion": 1,
      "sortOrder": "asc",  // Chronological order from the beginning
      "limit": 10,
      "transactionDetails": "full"
    }
  ]
}
```

Pour la création de pool de liquidités, interrogez l'adresse du pool :

```javascript theme={"system"}
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getTransactionsForAddress", 
  "params": [
    "POOL_ADDRESS_HERE", // Raydium/Meteora pool address
    {
      "transactionDetails": "full",
      "sortOrder": "asc",  // First transaction is usually pool creation
      "limit": 1
    }
  ]
}
```

Cela trouve le moment exact où une frappe ou un pool de liquidités a été créé, y compris l'adresse du créateur et les paramètres initiaux.

### Transactions de financement

Trouvez qui a financé une adresse spécifique :

```javascript theme={"system"}
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getTransactionsForAddress",
  "params": [
    "TARGET_WALLET_ADDRESS",
    {
      "transactionDetails": "full",
      "sortOrder": "asc",  // Oldest first
      "limit": 10
    }
  ]
}
```

Ensuite analysez les données de transaction pour trouver les transferts SOL :

```javascript theme={"system"}
response.result.data.forEach(tx => {
  // Look for SOL transfers in preBalances/postBalances
  const balanceChanges = tx.meta.preBalances.map((pre, index) => 
    tx.meta.postBalances[index] - pre
  );
  
  // Positive balance change = incoming SOL
  balanceChanges.forEach((change, index) => {
    if (change > 0) {
      console.log(`Received ${change} lamports from ${tx.transaction.message.accountKeys[index]}`);
    }
  });
});
```

Les premières transactions révèlent souvent la source de financement et peuvent aider à identifier des adresses liées ou des modèles de financement.

### Transferts de jetons

Filtrez par `tokenTransfer` pour isoler des mouvements de jetons spécifiques.

Entrées d'USDC vers une adresse :

```json theme={"system"}
{
  "filters": {
    "tokenTransfer": {
      "direction": "in",
      "mint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    }
  }
}
```

Gros transferts sortants vers une contrepartie spécifique :

```json theme={"system"}
{
  "filters": {
    "tokenTransfer": {
      "with": "9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM",
      "direction": "out",
      "amount": { "gte": 1000000000 }
    }
  }
}
```

Combiné avec la plage de créneaux et le statut :

```json theme={"system"}
{
  "filters": {
    "status": "succeeded",
    "slot": { "gte": 100000000, "lte": 200000000 },
    "tokenTransfer": {
      "direction": "in",
      "mint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
      "amount": { "gte": 5000000 }
    }
  }
}
```

## Pagination

Lorsque vous avez plus de transactions que votre limite, utilisez le `paginationToken` de la réponse pour récupérer la page suivante. Le jeton est une simple chaîne au format `"slot:position"` qui indique à l'API où continuer.

Utilisez le jeton de pagination de chaque réponse pour récupérer la page suivante :

```javascript theme={"system"}
// First request
let paginationToken = null;
let allTransactions = [];

const getNextPage = async (paginationToken = null) => {
  const params = [
    'ADDRESS',
    {
      transactionDetails: 'signatures',
      limit: 100,
      ...(paginationToken && { paginationToken })
    }
  ];

  const response = await fetch(rpcUrl, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 1,
      method: 'getTransactionsForAddress',
      params
    })
  });

  const data = await response.json();
  return data.result;
};

// Paginate through all results
do {
  const result = await getNextPage(paginationToken);
  allTransactions.push(...result.data);
  paginationToken = result.paginationToken;
  
  console.log(`Fetched ${result.data.length} transactions, total: ${allTransactions.length}`);
} while (paginationToken);
```

### Adresses multiples

Vous ne pouvez pas interroger plusieurs adresses dans une seule requête. Chaque requête d'adresse compte comme une requête API distincte et est mesurée en conséquence. Pour récupérer les transactions de plusieurs adresses, interrogez chaque adresse dans la même fenêtre de temps ou de créneaux, puis fusionnez et triez :

```javascript theme={"system"}
const addresses = ['Address1...', 'Address2...', 'Address3...'];

// Query all addresses in parallel with slot filter
const results = await Promise.all(
  addresses.map(address => 
    fetch(rpcUrl, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        jsonrpc: '2.0',
        id: 1,
        method: 'getTransactionsForAddress',
        params: [address, {
          sortOrder: 'desc',
          filters: { slot: { gt: 250000000 } }
        }]
      })
    }).then(r => r.json())
  )
);

// Merge and sort by slot
const allTransactions = results
  .flatMap(r => r.result.data)
  .sort((a, b) => b.slot - a.slot);
```

Pour des analyses historiques plus importantes, itérez à travers les fenêtres de temps ou de créneaux (par exemple, 1000 créneaux à la fois) et répétez ce modèle.

## Bonnes pratiques

**Performance.** Utilisez `transactionDetails: "signatures"` lorsque vous n'avez pas besoin de données transactionnelles complètes. Utilisez des tailles de page raisonnables pour de meilleurs temps de réponse, et filtrez par plages horaires ou créneaux spécifiques pour des requêtes plus ciblées.

**Filtrage.** Commencez avec des filtres larges et diminuez progressivement. Utilisez des filtres basés sur le temps pour les workflows d'analytique et de rapport, et combinez plusieurs filtres pour des requêtes précises qui ciblent des types de transactions ou des périodes spécifiques.

**Pagination.** Stockez les jetons de pagination lorsque vous avez besoin de reprendre des requêtes importantes plus tard. Surveillez la profondeur de pagination pour la planification de performance, et utilisez l'ordre croissant lorsque vous avez besoin de rejouer des événements historiques dans l'ordre chronologique.

**Gestion des erreurs.** Gérez les limites de taux de manière élégante avec un backoff exponentiel. Validez les adresses avant de faire des requêtes, et mettez en cache les résultats lorsque cela est approprié pour réduire l'utilisation de l'API.

## Limitations et cas particuliers

Un petit ensemble d'adresses route vers l'archivage hérité, est limité à la solution de contournement de scan de créneaux, ou renvoie vide. La découverte de comptes de jetons avant le créneau 111,491,819 nécessite également une solution de contournement. Développez les sections ci-dessous pour tous les détails.

<Accordion title="Adresses non prises en charge et spécialement routées">
  **Routées vers l'ancien archivage.** Les requêtes pour ces adresses sont routées vers notre ancien système d'archivage.

  | Adresse                                       | Nom                                                                                                               |
  | --------------------------------------------- | ----------------------------------------------------------------------------------------------------------------- |
  | `Stake11111111111111111111111111111111111111` | [Programme de Staking](https://orbmarkets.io/address/Stake11111111111111111111111111111111111111/history)         |
  | `StakeConfig11111111111111111111111111111111` | [Configuration de Staking](https://orbmarkets.io/address/StakeConfig11111111111111111111111111111111/history)     |
  | `Sysvar1111111111111111111111111111111111111` | [Propriétaire Sysvar](https://orbmarkets.io/address/Sysvar1111111111111111111111111111111111111/history)          |
  | `AddressLookupTab1e1111111111111111111111111` | [Table de Recherche d'Adresse](https://orbmarkets.io/address/AddressLookupTab1e1111111111111111111111111/history) |
  | `BPFLoaderUpgradeab1e11111111111111111111111` | [Chargeur BPF Upgradable](https://orbmarkets.io/address/BPFLoaderUpgradeab1e11111111111111111111111/history)      |

  **Solution de contournement du scan de créneaux.** Les requêtes pour ces adresses sont redirigées vers notre nouveau système d'archivage, et sont interrogeables via une approche de scan créneau par créneau (maximum 100 créneaux). Cependant, ces données ne sont pas indexées.

  | Adresse                                       | Nom                                                                                                    |
  | --------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
  | `11111111111111111111111111111111`            | [Programme Système](https://orbmarkets.io/address/11111111111111111111111111111111/history)            |
  | `ComputeBudget111111111111111111111111111111` | [Budget de Calcul](https://orbmarkets.io/address/ComputeBudget111111111111111111111111111111/history)  |
  | `MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr` | [Programme de Mémo](https://orbmarkets.io/address/MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr/history) |
  | `Vote111111111111111111111111111111111111111` | [Programme de Vote](https://orbmarkets.io/address/Vote111111111111111111111111111111111111111/history) |

  **Retourne vide (`is_reserved_address`).** Les requêtes sont transférées vers notre nouveau système d'archivage, cependant les données ne sont pas indexées, et les requêtes retournent vides.

  | Adresse                                        | Nom                                                                                                                           |
  | ---------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
  | `BPFLoader1111111111111111111111111111111111`  | [Chargeur BPF (déprécié)](https://orbmarkets.io/address/BPFLoader1111111111111111111111111111111111/history)                  |
  | `BPFLoader2111111111111111111111111111111111`  | [Chargeur BPF](https://orbmarkets.io/address/BPFLoader2111111111111111111111111111111111/history)                             |
  | `Config1111111111111111111111111111111111111`  | [Programme de Configuration](https://orbmarkets.io/address/Config1111111111111111111111111111111111111/history)               |
  | `Ed25519SigVerify111111111111111111111111111`  | [Programme Ed25519](https://orbmarkets.io/address/Ed25519SigVerify111111111111111111111111111/history)                        |
  | `Feature111111111111111111111111111111111111`  | [Programme de Fonctionnalités](https://orbmarkets.io/address/Feature111111111111111111111111111111111111/history)             |
  | `KeccakSecp256k11111111111111111111111111111`  | [Programme Secp256k1](https://orbmarkets.io/address/KeccakSecp256k11111111111111111111111111111/history)                      |
  | `LoaderV411111111111111111111111111111111111`  | [Chargeur V4](https://orbmarkets.io/address/LoaderV411111111111111111111111111111111111/history)                              |
  | `NativeLoader1111111111111111111111111111111`  | [Chargeur Natif](https://orbmarkets.io/address/NativeLoader1111111111111111111111111111111/history)                           |
  | `SysvarC1ock11111111111111111111111111111111`  | [Sysvar Horloge](https://orbmarkets.io/address/SysvarC1ock11111111111111111111111111111111/history)                           |
  | `SysvarEpochSchedu1e111111111111111111111111`  | [Sysvar de Programme d'Époque](https://orbmarkets.io/address/SysvarEpochSchedu1e111111111111111111111111/history)             |
  | `SysvarFees111111111111111111111111111111111`  | [Sysvar de Frais](https://orbmarkets.io/address/SysvarFees111111111111111111111111111111111/history)                          |
  | `Sysvar1nstructions1111111111111111111111111`  | [Sysvar d'Inscriptions](https://orbmarkets.io/address/Sysvar1nstructions1111111111111111111111111/history)                    |
  | `SysvarRecentB1ockHashes11111111111111111111`  | [Sysvar de Hachages de Blocs Récents](https://orbmarkets.io/address/SysvarRecentB1ockHashes11111111111111111111/history)      |
  | `SysvarRent111111111111111111111111111111111`  | [Sysvar de Location](https://orbmarkets.io/address/SysvarRent111111111111111111111111111111111/history)                       |
  | `SysvarRewards111111111111111111111111111111`  | [Sysvar de Récompenses](https://orbmarkets.io/address/SysvarRewards111111111111111111111111111111/history)                    |
  | `SysvarS1otHashes111111111111111111111111111`  | [Sysvar de Hachages de Créneaux](https://orbmarkets.io/address/SysvarS1otHashes111111111111111111111111111/history)           |
  | `SysvarS1otHistory11111111111111111111111111`  | [Sysvar d'Historique de Créneaux](https://orbmarkets.io/address/SysvarS1otHistory11111111111111111111111111/history)          |
  | `SysvarStakeHistory1111111111111111111111111`  | [Sysvar d'Historique de Staking](https://orbmarkets.io/address/SysvarStakeHistory1111111111111111111111111/history)           |
  | `SysvarEpochRewards11111111111111111111111111` | [Sysvar de Récompenses d'Époque](https://orbmarkets.io/address/SysvarEpochRewards11111111111111111111111111/history)          |
  | `SysvarLastRestartS1ot1111111111111111111111`  | [Sysvar du Dernier Redémarrage de Créneau](https://orbmarkets.io/address/SysvarLastRestartS1ot1111111111111111111111/history) |
</Accordion>

<Accordion title="Solution de contournement : découverte de comptes de jetons historiques (avant le créneau 111,491,819)">
  Pour les adresses avec de l'activité de compte de jetons avant le créneau 111,491,819, le filtre `tokenAccounts` ne peut pas déterminer la propriété car le champ `owner` dans les métadonnées de solde de jetons n'existait pas encore. Pour obtenir des résultats complets, vous pouvez découvrir ces comptes de jetons manuellement en analysant les premières instructions de transaction, puis interroger `getTransactionsForAddress` en parallèle pour chaque compte.

  ```javascript theme={"system"}
  const HELIUS_RPC = "https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY";
  const OWNER_CUTOFF_SLOT = 111_491_819;

  async function rpcCall(method, params) {
    const res = await fetch(HELIUS_RPC, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ jsonrpc: "2.0", id: "1", method, params }),
    });
    const json = await res.json();
    if (json.error) throw new Error(json.error.message);
    return json.result;
  }

  // Step 1: Discover token accounts owned by the address before the cutoff slot
  // by parsing initializeAccount instructions and transfer authorities.
  async function discoverHistoricalTokenAccounts(address) {
    const tokenAccounts = new Set();
    let paginationToken = null;

    do {
      const result = await rpcCall("getTransactionsForAddress", [
        address,
        {
          transactionDetails: "full",
          encoding: "jsonParsed",
          maxSupportedTransactionVersion: 1,
          sortOrder: "asc",
          limit: 100,
          filters: { slot: { lt: OWNER_CUTOFF_SLOT } },
          ...(paginationToken && { paginationToken }),
        },
      ]);
      if (!result?.data?.length) break;

      for (const entry of result.data) {
        const tx = entry.transaction;
        const meta = entry.meta;
        if (!tx || !meta) continue;

        const allInstructions = [
          ...(tx.message?.instructions ?? []),
          ...(meta.innerInstructions ?? []).flatMap((inner) => inner.instructions ?? []),
        ];

        for (const ix of allInstructions) {
          // AToken program "create" instruction
          if (ix.program === "spl-associated-token-account") {
            if (ix.parsed?.type === "create" && ix.parsed.info?.wallet === address && ix.parsed.info?.account) {
              tokenAccounts.add(ix.parsed.info.account);
            }
            continue;
          }

          if (ix.program !== "spl-token" && ix.program !== "spl-token-2022") continue;
          const type = ix.parsed?.type;
          const info = ix.parsed?.info;

          // Token account initialization
          if (type === "initializeAccount" || type === "initializeAccount2" || type === "initializeAccount3") {
            if (info?.owner === address && info?.account) tokenAccounts.add(info.account);
          }

          // Transfers where our address is the authority (source account is ours)
          if (type === "transfer" || type === "transferChecked") {
            if (info?.authority === address && info?.source) tokenAccounts.add(info.source);
          }
        }
      }
      paginationToken = result.paginationToken;
    } while (paginationToken);

    return Array.from(tokenAccounts);
  }

  // Step 2: Fetch all signatures for an address with pagination
  async function fetchAllSignatures(address, filters) {
    const allSignatures = [];
    let paginationToken = null;

    do {
      const result = await rpcCall("getTransactionsForAddress", [
        address,
        {
          transactionDetails: "signatures",
          sortOrder: "asc",
          limit: 1000,
          ...(filters && { filters }),
          ...(paginationToken && { paginationToken }),
        },
      ]);
      if (!result?.data?.length) break;
      allSignatures.push(...result.data);
      paginationToken = result.paginationToken;
    } while (paginationToken);

    return allSignatures;
  }

  // Step 3: Get complete history by combining tokenAccounts:"all" with
  // individual queries for historical token accounts
  async function getCompleteHistory(address) {
    const historicalAccounts = await discoverHistoricalTokenAccounts(address);

    if (historicalAccounts.length === 0) {
      return fetchAllSignatures(address, { tokenAccounts: "all" });
    }

    // Query main address with tokenAccounts:"all" + each historical account in parallel
    const results = await Promise.all([
      fetchAllSignatures(address, { tokenAccounts: "all" }),
      ...historicalAccounts.map((addr) => fetchAllSignatures(addr)),
    ]);

    // Merge and deduplicate by signature
    const seen = new Set();
    const merged = [];
    for (const batch of results) {
      for (const tx of batch) {
        if (!seen.has(tx.signature)) {
          seen.add(tx.signature);
          merged.push(tx);
        }
      }
    }
    return merged.sort((a, b) => a.slot - b.slot);
  }
  ```
</Accordion>

## En quoi est-ce différent de getSignaturesForAddress?

Si vous connaissez la méthode standard `getSignaturesForAddress`, `getTransactionsForAddress` réduit les workflows en plusieurs étapes à un seul appel et ajoute le filtrage, le tri et le support des comptes de jetons. Pour une conversion étape par étape du code existant, consultez le [guide de migration](/docs/fr/rpc/migrate-to-gettransactionsforaddress).

### Obtenez des transactions complètes en un seul appel

Avec `getSignaturesForAddress`, vous avez besoin de deux étapes :

```javascript theme={"system"}
// Step 1: Get signatures
const signatures = await connection.getSignaturesForAddress(address, { limit: 1000 });

// Step 2: Get transaction details (1,000 additional calls!)
const transactions = await Promise.all(
  signatures.map(sig => connection.getTransaction(sig.signature))
);
```

Avec `getTransactionsForAddress`, c'est un seul appel :

```javascript theme={"system"}
const response = await fetch(heliusRpcUrl, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: 1,
    method: 'getTransactionsForAddress',
    params: [
      address,
      {
        transactionDetails: 'full',
        limit: 1000
      }
    ]
  })
});
```

### Obtenez l'historique des jetons en un seul appel

Avec `getSignaturesForAddress`, vous devez d'abord appeler `getTokenAccountsByOwner` puis interroger pour chaque compte de jetons :

```javascript theme={"system"}
// OLD WAY (with getSignaturesForAddress)
// Step 1: Get all token accounts owned by this wallet
const tokenAccounts = await connection.getTokenAccountsByOwner(
  new PublicKey(walletAddress),
  { programId: TOKEN_PROGRAM_ID }
);

// Step 2: Fetch signatures for the wallet itself
const walletSignatures = await connection.getSignaturesForAddress(
  new PublicKey(walletAddress),
  { limit: 1000 }
);

// Step 3: Fetch signatures for EVERY token account (this is the painful part)
const tokenAccountSignatures = await Promise.all(
  tokenAccounts.value.map(async (account) => {
    return connection.getSignaturesForAddress(
      account.pubkey,
      { limit: 1000 }
    );
  })
);

// Step 4: Merge all results together
const allSignatures = [
  ...walletSignatures,
  ...tokenAccountSignatures.flat()
];

// Step 5: Deduplicate (many transactions touch multiple accounts)
const seen = new Set();
const uniqueSignatures = allSignatures.filter((sig) => {
  if (seen.has(sig.signature)) {
    return false;
  }
  seen.add(sig.signature);
  return true;
});

// Step 6: Sort chronologically
const sortedSignatures = uniqueSignatures.sort(
  (a, b) => a.slot - b.slot
);

return sortedSignatures;
```

Avec `getTransactionsForAddress`, vous n'avez qu'à définir `filters.tokenAccounts` :

```javascript theme={"system"}
// NEW WAY (with getTransactionsForAddress)
const response = await fetch("https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    jsonrpc: "2.0",
    id: "helius-example",
    method: "getTransactionsForAddress",
    params: [
      walletAddress,
      {
        filters: {
          tokenAccounts: "all"
        },
        sortOrder: "asc",
        limit: 100
      }
    ]
  })
});

const { result } = await response.json();
return result;
```

### Capacités supplémentaires

<CardGroup cols={2}>
  <Card title="Tri chronologique" icon="arrow-up">
    Triez les transactions du plus ancien au plus récent avec `sortOrder: 'asc'`.
  </Card>

  <Card title="Filtrage basé sur le temps" icon="clock">
    Filtrez par plages horaires à l'aide des filtres `blockTime`.
  </Card>

  <Card title="Filtrage par statut" icon="filter">
    Obtenez uniquement les transactions réussies ou échouées avec le filtre `status`.
  </Card>

  <Card title="Pagination simplifiée" icon="list">
    Utilisez `paginationToken` au lieu de `before`/`until`.
  </Card>
</CardGroup>

## Étapes suivantes

<CardGroup cols={2}>
  <Card title="Guide d'indexation" icon="layer-group" href="/docs/fr/rpc/how-to-index-solana-data">
    Utilisez getTransactionsForAddress pour le remplissage rétroactif et la synchronisation d'un index Solana.
  </Card>

  <Card title="getTransfersByAddress" icon="arrow-right-arrow-left" href="/docs/fr/rpc/gettransfersbyaddress">
    Historique analysé, axé uniquement sur les transferts pour les paiements et la réconciliation.
  </Card>

  <Card title="Référence API" icon="code" href="/docs/fr/api-reference/rpc/http/gettransactionsforaddress">
    Schéma complet de requête et de réponse pour getTransactionsForAddress.
  </Card>

  <Card title="Vue d'ensemble des données historiques" icon="clock-rotate-left" href="/docs/fr/rpc/historical-data">
    Comparez toutes les méthodes de données historiques de Solana.
  </Card>
</CardGroup>