> ## 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.

# Historique des transactions

> Obtenez un historique de transactions lisible pour toute adresse Solana avec des options de filtrage, de plages temporelles et de slots, ainsi que de pagination.

<Warning>
  L'API Enhanced Transactions est un produit en mode maintenance. Elle fonctionne toujours et ces pages restent disponibles, mais elle ne reçoit pas de nouveaux types d'analyseurs ni d'améliorations. Son successeur est [Parsed Events](/docs/fr/parsed-events), qui décode les instructions via le catalogue IDL et est en bêta ouverte sur les plans payants — le [guide de migration](/docs/fr/parsed-events/guides/migrate-from-enhanced-transactions) couvre le processus étape par étape. Vous pouvez également utiliser [`getTransactionsForAddress`](/docs/fr/rpc/gettransactionsforaddress) pour l'historique des transactions et le remplissage rétroactif, ainsi que l'[API Wallet](/docs/fr/wallet-api/overview) pour des données de portefeuille lisibles.
</Warning>

## Aperçu

Le point de terminaison de l'historique des transactions renvoie un historique de transactions lisible pour toute adresse Solana. Au lieu de gérer des données d'instruction brutes et des listes de comptes, vous obtenez des informations structurées concernant :

* Ce qui s'est passé dans la transaction (transferts, échanges, activités NFT).
* Quels comptes étaient impliqués.
* Combien de SOL ou de jetons ont été transférés.
* Métadonnées associées (adresses de frappe de jetons, noms de jetons, symboles de jetons, et plus).

Envoyez une demande `GET` à `/v0/addresses/{address}/transactions`. Sous le capot, ce point de terminaison est alimenté par la méthode RPC [`getTransactionsForAddress`](/docs/fr/rpc/gettransactionsforaddress).

## Quand l'utiliser

* Vous affichez l'historique des transactions d'une adresse aux utilisateurs (portefeuilles, trackers de portefeuille, explorateurs).
* Vous souhaitez un historique pré-analysé et lisible sans avoir à écrire votre propre décodeur.
* Vous avez besoin de filtrer l'historique par type de transaction, plage temporelle ou plage de slots.
* Vous avez besoin de l'historique complet d'un portefeuille en jetons, y compris les comptes de jetons associés (ATA) — voir ci-dessous.

Pour les nouvelles constructions, [`getTransactionsForAddress`](/docs/fr/rpc/gettransactionsforaddress) est la solution moderne, native Helius, avec filtrage côté serveur et recherches de comptes de jetons.

## Démarrage rapide

<Steps>
  <Step title="Obtenez votre clé API">
    Inscrivez-vous sur [dashboard.helius.dev](https://dashboard.helius.dev) et copiez votre clé API.
  </Step>

  <Step title="Obtenez l'endpoint des transactions d'adresse">
    Récupérez l'historique des transactions pour toute adresse Solana.

    <Tabs>
      <Tab title="JavaScript">
        ```javascript theme={"system"}
        const fetchWalletTransactions = async () => {
          const walletAddress = "M2mx93ekt1fmXSVkTrUL9xVFHkmME8HTUi5Cyc5aF7K"; // Replace with target wallet
          const url = `https://mainnet.helius-rpc.com/v0/addresses/${walletAddress}/transactions?api-key=YOUR_API_KEY`;

          const response = await fetch(url);
          const transactions = await response.json();
          console.log("Wallet transactions:", transactions);
        };

        fetchWalletTransactions();
        ```
      </Tab>

      <Tab title="Python">
        ```python theme={"system"}
        import requests

        def fetch_wallet_transactions():
            wallet_address = "M2mx93ekt1fmXSVkTrUL9xVFHkmME8HTUi5Cyc5aF7K"  # Replace with target wallet
            url = f"https://mainnet.helius-rpc.com/v0/addresses/{wallet_address}/transactions?api-key=YOUR_API_KEY"

            response = requests.get(url)
            transactions = response.json()
            print("Wallet transactions:", transactions)

        fetch_wallet_transactions()
        ```
      </Tab>
    </Tabs>
  </Step>

  <Step title="Filtrer et paginer">
    Réduisez les résultats avec les filtres `type`, temps et slots ci-dessous, puis parcourez les adresses à volume élevé avec des curseurs de signature.
  </Step>
</Steps>

## Support de réseau

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

## Paramètres de la requête

| Paramètre          | Description                                                                          | Défaut      | Exemple                          |
| ------------------ | ------------------------------------------------------------------------------------ | ----------- | -------------------------------- |
| `limit`            | Nombre de transactions à retourner (1-100)                                           | 10          | `&limit=25`                      |
| `before-signature` | Récupérez les transactions avant cette signature (à utiliser avec `sort-order=desc`) | -           | `&before-signature=sig123...`    |
| `after-signature`  | Récupérez les transactions après cette signature (à utiliser avec `sort-order=asc`)  | -           | `&after-signature=sig456...`     |
| `type`             | Filtrer par type de transaction                                                      | -           | `&type=NFT_SALE`                 |
| `sort-order`       | Ordre de tri des résultats                                                           | `desc`      | `&sort-order=asc`                |
| `token-accounts`   | Filtrer les transactions pour les comptes de jetons associés                         | `none`      | `&token-accounts=balanceChanged` |
| `commitment`       | Niveau d'engagement                                                                  | `finalized` | `&commitment=confirmed`          |

### Filtrage basé sur le temps

| Paramètre  | Description                               | Exemple                |
| ---------- | ----------------------------------------- | ---------------------- |
| `gt-time`  | Transactions après ce timestamp Unix      | `&gt-time=1656442333`  |
| `gte-time` | Transactions à ou après ce timestamp Unix | `&gte-time=1656442333` |
| `lt-time`  | Transactions avant ce timestamp Unix      | `&lt-time=1656442333`  |
| `lte-time` | Transactions à ou avant ce timestamp Unix | `&lte-time=1656442333` |

### Filtrage basé sur les slots

| Paramètre  | Description                     | Exemple               |
| ---------- | ------------------------------- | --------------------- |
| `gt-slot`  | Transactions après ce slot      | `&gt-slot=148277128`  |
| `gte-slot` | Transactions à ou après ce slot | `&gte-slot=148277128` |
| `lt-slot`  | Transactions avant ce slot      | `&lt-slot=148277128`  |
| `lte-slot` | Transactions à ou avant ce slot | `&lte-slot=148277128` |

Notes de filtrage :

* Les paramètres basés sur le temps utilisent les timestamps Unix (secondes depuis l'époque) ; les paramètres basés sur les slots utilisent les numéros de slots Solana.
* Vous ne pouvez pas combiner les filtres basés sur le temps et les filtres basés sur les slots dans la même requête.
* Utilisez `sort-order=asc` pour l'ordre croissant (le plus ancien d'abord) ou `sort-order=desc` pour l'ordre décroissant (le plus récent d'abord).
* Utilisez les filtres temps ou slots pour réduire l'espace de recherche lorsque vous connaissez la période approximative et associez-les à `limit` pour contrôler la taille de la page.

## 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 détiennent les jetons. Lorsqu'on vous envoie des USDC, ils vont sur votre compte de jetons USDC plutôt que sur votre adresse principale de portefeuille.

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

Le filtre `token-accounts` contrôle ce comportement :

* **`none`** (par défaut) — ne renvoie que les transactions qui référencent directement l'adresse du portefeuille. Utilisez-le lorsque vous vous souciez uniquement des interactions directes avec le portefeuille.
* **`balanceChanged`** (recommandé) — renvoie les transactions qui référencent 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 comme les collectes de frais ou les délégations, vous donnant une vue claire des activités significatives du portefeuille.
* **`all`** — renvoie toutes les transactions qui référencent l'adresse du portefeuille ou tout compte de jetons détenu par le portefeuille.

<Warning>
  Le filtre `token-accounts` repose sur le champ `owner` dans les métadonnées des soldes de jetons, qui n'était pas disponible avant le slot 111,491,819 (\~décembre 2022). Les transactions impliquant des comptes de jetons actifs avant ce slot peuvent être absentes des résultats `balanceChanged` et `all`. Consultez le tutoriel [getTransactionsForAddress](/docs/fr/rpc/gettransactionsforaddress#limitations-et-cas-particuliers) pour une solution de contournement avec un exemple de code complet.
</Warning>

## Filtres

### Filtrer par type de transaction

Obtenez uniquement des types de transactions spécifiques, tels que les ventes NFT, les transferts de jetons ou les échanges :

<Tabs>
  <Tab title="Ventes NFT">
    ```javascript theme={"system"}
    const fetchNftSales = async () => {
      const tokenAddress = "GjUG1BATg5V4bdAr1csKys1XK9fmrbntgb1iV7rAkn94"; // NFT mint address
      const url = `https://mainnet.helius-rpc.com/v0/addresses/${tokenAddress}/transactions?api-key=YOUR_API_KEY&type=NFT_SALE`;

      const response = await fetch(url);
      const nftSales = await response.json();
      console.log("NFT sale transactions:", nftSales);
    };
    ```
  </Tab>

  <Tab title="Transferts de jetons">
    ```javascript theme={"system"}
    const fetchTokenTransfers = async () => {
      const walletAddress = "M2mx93ekt1fmXSVkTrUL9xVFHkmME8HTUi5Cyc5aF7K"; // Wallet address
      const url = `https://mainnet.helius-rpc.com/v0/addresses/${walletAddress}/transactions?api-key=YOUR_API_KEY&type=TRANSFER`;

      const response = await fetch(url);
      const transfers = await response.json();
      console.log("Transfer transactions:", transfers);
    };
    ```
  </Tab>

  <Tab title="Échanges">
    ```javascript theme={"system"}
    const fetchSwapTransactions = async () => {
      const walletAddress = "M2mx93ekt1fmXSVkTrUL9xVFHkmME8HTUi5Cyc5aF7K"; // Wallet address
      const url = `https://mainnet.helius-rpc.com/v0/addresses/${walletAddress}/transactions?api-key=YOUR_API_KEY&type=SWAP`;

      const response = await fetch(url);
      const swaps = await response.json();
      console.log("Swap transactions:", swaps);
    };
    ```
  </Tab>
</Tabs>

Pour la liste complète des types de transactions pris en charge, consultez la [référence de l'API d'historique des transactions](/docs/fr/api-reference/enhanced-transactions/gettransactionsbyaddress).

### Filtrage par type au moment de l'exécution

<Note>
  Le filtrage par type se fait au moment de l'exécution : l'API cherche les transactions séquentiellement jusqu'à ce qu'elle trouve au moins 50 éléments correspondants. Si elle ne peut pas trouver de correspondances dans la fenêtre de recherche, elle renvoie une erreur avec une signature pour continuer la recherche. C'est un comportement prévu, pas une défaillance.
</Note>

Lorsqu'aucune transaction correspondante n'est trouvée dans la fenêtre de recherche actuelle, l'API renvoie une réponse d'erreur comme suit :

```json theme={"system"}
{
  "error": "Failed to find events within the search period. To continue search, query the API again with the `before-signature` parameter set to 2UKbsu95YzxGjUGYRg2znozmmVADVgmnhHqzDxq8Xfb3V5bf2NHUkaXGPrUpQnRFVHVKbawdQXtm4xJt9njMDHvg."
}
```

Pour continuer, utilisez la signature du message d'erreur avec le paramètre approprié (`before-signature` pour décroissant, `after-signature` pour croissant) pour votre prochaine requête.

<Accordion title="Boucle de continuation pour les filtres de type (exemple complet)">
  ```javascript theme={"system"}
  const fetchFilteredTransactions = async (sortOrder = 'desc') => {
    const walletAddress = "M2mx93ekt1fmXSVkTrUL9xVFHkmME8HTUi5Cyc5aF7K";
    const transactionType = "NFT_SALE";
    let continuationSignature = null;
    let allFilteredTransactions = [];
    let maxRetries = 10; // Prevent infinite loops
    let retryCount = 0;

    // Determine which parameter to use based on sort order
    const continuationParam = sortOrder === 'asc' ? 'after-signature' : 'before-signature';

    while (retryCount < maxRetries) {
      // Build URL with optional continuation parameter
      let url = `https://mainnet.helius-rpc.com/v0/addresses/${walletAddress}/transactions?api-key=YOUR_API_KEY&type=${transactionType}&sort-order=${sortOrder}`;

      if (continuationSignature) {
        url += `&${continuationParam}=${continuationSignature}`;
      }

      try {
        const response = await fetch(url);
        const data = await response.json();

        // Check if we received an error about search period
        if (data.error && data.error.includes("Failed to find events within the search period")) {
          // Extract the signature from the error message
          const signatureMatch = data.error.match(/parameter set to ([A-Za-z0-9]+)/);

          if (signatureMatch && signatureMatch[1]) {
            console.log(`No results in this period. Continuing search from: ${signatureMatch[1]}`);
            continuationSignature = signatureMatch[1];
            retryCount++;
            continue; // Continue searching with new signature
          } else {
            console.log("No more transactions to search");
            break;
          }
        }

        // Check if we received transactions
        if (Array.isArray(data) && data.length > 0) {
          console.log(`Found ${data.length} ${transactionType} transactions`);
          allFilteredTransactions = [...allFilteredTransactions, ...data];

          // Set continuation signature for next page
          continuationSignature = data[data.length - 1].signature;
          retryCount = 0; // Reset retry count since we found results
        } else {
          console.log("No more transactions found");
          break;
        }

      } catch (error) {
        console.error("Error fetching transactions:", error);
        break;
      }
    }

    console.log(`Total ${transactionType} transactions found: ${allFilteredTransactions.length}`);
    return allFilteredTransactions;
  };

  // Usage examples:
  // Descending order (newest first) - uses 'before-signature' parameter
  fetchFilteredTransactions('desc');

  // Ascending order (oldest first) - uses 'after-signature' parameter
  fetchFilteredTransactions('asc');
  ```

  Points clés :

  * L'API recherche jusqu'à 50 transactions à la fois lors de l'utilisation de filtres de type.
  * Si aucune correspondance n'est trouvée, utilisez la signature du message d'erreur pour continuer à chercher.
  * Utilisez `before-signature` lors de recherches en ordre décroissant (défaut, le plus récent d'abord).
  * Utilisez `after-signature` lors de recherches en ordre croissant (le plus ancien d'abord) — requis pour les recherches chronologiques.
  * Implémentez une limite maximale de réessai pour éviter les boucles infinies.
</Accordion>

## Exemples

Les scénarios suivants couvrent les plages de temps et de slots, l'ordre de tri, les ATA et les filtres combinés.

<Accordion title="Filtrer par plage de temps">
  Obtenez des transactions dans une fenêtre temporelle spécifique :

  <Tabs>
    <Tab title="Dernières 24 heures">
      ```javascript theme={"system"}
      const fetchRecentTransactions = async () => {
        const walletAddress = "M2mx93ekt1fmXSVkTrUL9xVFHkmME8HTUi5Cyc5aF7K";
        const now = Math.floor(Date.now() / 1000);
        const oneDayAgo = now - (24 * 60 * 60);

        const url = `https://mainnet.helius-rpc.com/v0/addresses/${walletAddress}/transactions?api-key=YOUR_API_KEY&gte-time=${oneDayAgo}&lte-time=${now}`;

        const response = await fetch(url);
        const transactions = await response.json();
        console.log("Transactions from last 24 hours:", transactions);
      };
      ```
    </Tab>

    <Tab title="Plage de dates spécifique">
      ```javascript theme={"system"}
      const fetchTransactionsByDateRange = async () => {
        const walletAddress = "M2mx93ekt1fmXSVkTrUL9xVFHkmME8HTUi5Cyc5aF7K";

        // January 1, 2024 to January 31, 2024
        const startTime = Math.floor(new Date('2024-01-01').getTime() / 1000);
        const endTime = Math.floor(new Date('2024-01-31').getTime() / 1000);

        const url = `https://mainnet.helius-rpc.com/v0/addresses/${walletAddress}/transactions?api-key=YOUR_API_KEY&gte-time=${startTime}&lte-time=${endTime}`;

        const response = await fetch(url);
        const transactions = await response.json();
        console.log("Transactions in January 2024:", transactions);
      };
      ```
    </Tab>
  </Tabs>
</Accordion>

<Accordion title="Filtrer par plage de slots">
  Obtenez des transactions dans une plage de slots spécifique :

  ```javascript theme={"system"}
  const fetchTransactionsBySlotRange = async () => {
    const walletAddress = "M2mx93ekt1fmXSVkTrUL9xVFHkmME8HTUi5Cyc5aF7K";
    const startSlot = 148000000;
    const endSlot = 148100000;

    const url = `https://mainnet.helius-rpc.com/v0/addresses/${walletAddress}/transactions?api-key=YOUR_API_KEY&gte-slot=${startSlot}&lte-slot=${endSlot}`;

    const response = await fetch(url);
    const transactions = await response.json();
    console.log(`Transactions between slots ${startSlot} and ${endSlot}:`, transactions);
  };
  ```
</Accordion>

<Accordion title="Changer l'ordre de tri">
  Obtenez des transactions en ordre croissant (le plus ancien d'abord) :

  ```javascript theme={"system"}
  const fetchOldestTransactions = async () => {
    const walletAddress = "M2mx93ekt1fmXSVkTrUL9xVFHkmME8HTUi5Cyc5aF7K";
    const url = `https://mainnet.helius-rpc.com/v0/addresses/${walletAddress}/transactions?api-key=YOUR_API_KEY&sort-order=asc&limit=10`;

    const response = await fetch(url);
    const transactions = await response.json();
    console.log("10 oldest transactions:", transactions);
  };
  ```
</Accordion>

<Accordion title="Inclure les transferts pour les comptes de jetons associés">
  Interrogez l'historique complet d'un portefeuille, y compris les adresses de jetons associées (ATA) :

  ```javascript theme={"system"}
  const fetchTransactionsWithATA = async () => {
    const walletAddress = "M2mx93ekt1fmXSVkTrUL9xVFHkmME8HTUi5Cyc5aF7K";

    const url = `https://mainnet.helius-rpc.com/v0/addresses/${walletAddress}/transactions?api-key=YOUR_API_KEY&token-accounts=balanceChanged&sort-order=desc&limit=50`;

    const response = await fetch(url);
    const transactions = await response.json();
    console.log("Most recent transactions (including ATA transfers)", transactions);
  };
  ```
</Accordion>

<Accordion title="Combiner plusieurs filtres">
  Combinez le filtrage par type avec une plage de temps et un ordre de tri personnalisé :

  ```javascript theme={"system"}
  const fetchFilteredTransactionsAdvanced = async () => {
    const walletAddress = "M2mx93ekt1fmXSVkTrUL9xVFHkmME8HTUi5Cyc5aF7K";

    // Get NFT sales from the last 7 days, oldest first
    const now = Math.floor(Date.now() / 1000);
    const sevenDaysAgo = now - (7 * 24 * 60 * 60);

    const url = `https://mainnet.helius-rpc.com/v0/addresses/${walletAddress}/transactions?api-key=YOUR_API_KEY&type=NFT_SALE&gte-time=${sevenDaysAgo}&sort-order=asc&limit=50`;

    const response = await fetch(url);
    const transactions = await response.json();
    console.log("NFT sales from last 7 days (oldest first):", transactions);
  };
  ```
</Accordion>

## Pagination

Pour les adresses à fort volume, parcourez les résultats en utilisant la dernière signature de chaque lot comme curseur :

```javascript theme={"system"}
const fetchAllTransactions = async () => {
  const walletAddress = "2k5AXX4guW9XwRQ1AKCpAuUqgWDpQpwFfpVFh3hnm2Ha"; // Replace with target wallet
  const baseUrl = `https://mainnet.helius-rpc.com/v0/addresses/${walletAddress}/transactions?api-key=YOUR_API_KEY`;
  let url = baseUrl;
  let lastSignature = null;
  let allTransactions = [];

  while (true) {
    if (lastSignature) {
      url = baseUrl + `&before-signature=${lastSignature}`;
    }

    const response = await fetch(url);

    // Check response status
    if (!response.ok) {
      console.error(`API error: ${response.status}`);
      break;
    }

    const transactions = await response.json();

    if (transactions && transactions.length > 0) {
      console.log(`Fetched batch of ${transactions.length} transactions`);
      allTransactions = [...allTransactions, ...transactions];
      lastSignature = transactions[transactions.length - 1].signature;
    } else {
      console.log(`Finished! Total transactions: ${allTransactions.length}`);
      break;
    }
  }

  return allTransactions;
};
```

Pour paginer dans une plage temporelle, gardez les filtres de temps sur chaque requête et avancez le curseur `before-signature` à chaque boucle :

```javascript theme={"system"}
const fetchAllTransactionsInTimeRange = async () => {
  const walletAddress = "M2mx93ekt1fmXSVkTrUL9xVFHkmME8HTUi5Cyc5aF7K";
  const startTime = Math.floor(new Date('2024-01-01').getTime() / 1000);
  const endTime = Math.floor(new Date('2024-01-31').getTime() / 1000);

  let beforeSignature = null;
  let allTransactions = [];

  while (true) {
    let url = `https://mainnet.helius-rpc.com/v0/addresses/${walletAddress}/transactions?api-key=YOUR_API_KEY&gte-time=${startTime}&lte-time=${endTime}&limit=100`;

    if (beforeSignature) {
      url += `&before-signature=${beforeSignature}`;
    }

    const response = await fetch(url);
    const transactions = await response.json();

    if (!Array.isArray(transactions) || transactions.length === 0) {
      break;
    }

    allTransactions = [...allTransactions, ...transactions];
    beforeSignature = transactions[transactions.length - 1].signature;

    console.log(`Fetched ${transactions.length} transactions, total: ${allTransactions.length}`);
  }

  console.log(`Total transactions in time range: ${allTransactions.length}`);
  return allTransactions;
};
```

## Prochaines étapes

<CardGroup cols={2}>
  <Card title="getTransactionsForAddress" icon="clock-rotate-left" href="/docs/fr/rpc/gettransactionsforaddress">
    Le remplacement moderne, natif Helius pour l'historique des transactions et le remplissage rétroactif.
  </Card>

  <Card title="API Wallet" icon="wallet" href="/docs/fr/wallet-api/overview">
    Points de terminaison REST pour des données de portefeuille lisibles : soldes, historique et transferts.
  </Card>

  <Card title="Analyser les transactions" icon="code" href="/docs/fr/enhanced-transactions/parse-transactions">
    Analyser une ou plusieurs signatures de transaction en données lisibles.
  </Card>

  <Card title="Aperçu de l'obtention de données" icon="database" href="/docs/fr/getting-data">
    Comparez chaque option Helius pour interroger les données Solana.
  </Card>
</CardGroup>