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

# getHistoricalTokenAccountsByOwner

> Répertoriez les comptes SPL Token et Token-2022 qu'un portefeuille Solana possédait à un slot passé ou juste après une transaction spécifique, avec des filtres par mint et la pagination.

> [!NOTE]
>
> `getHistoricalTokenAccountsByOwner` est en version bêta. Les paramètres, la tarification, les formats de réponse et la couverture des données peuvent changer.

## Présentation

`getHistoricalTokenAccountsByOwner` renvoie les comptes SPL Token et Token-2022 qu'un portefeuille possédait à un slot passé, ou immédiatement après une transaction spécifique de ce slot. Il s'agit d'une méthode RPC exclusive à Helius. La méthode standard `getTokenAccountsByOwner` renvoie uniquement l'état actuel.

Avec l'encodage `jsonParsed`, les montants des jetons utilisent le nombre de décimales de chaque mint à la position demandée. Les soldes reflètent donc ce que le portefeuille détenait à ce moment-là.

L'historique est disponible à partir du slot 444,959,999 (7 septembre 2026), qui correspond à l'état au début de l'époque 1030.

`getHistoricalTokenAccountsByOwner` est disponible sur le mainnet pour les offres Business et supérieures. Chaque appel coûte 0 crédit pendant la période bêta. La tarification est susceptible de changer.

## Différences avec getTokenAccountsByOwner

* **Le filtre par mint ou par programme est facultatif.** Sans filtre, vous obtenez tous les comptes de jetons que le portefeuille possédait. Pour affiner les résultats, définissez soit `mint`, soit `programId` dans l'objet de configuration (le troisième paramètre), mais pas les deux.
* **Le deuxième paramètre est l'objet de requête** qui sélectionne la position dans l'historique, et non un filtre par mint ou par programme.
* **`result.value` est un objet** contenant `accounts` et `paginationKey`, et non un tableau.

## Choisir une position dans l'historique

Le deuxième paramètre est un objet de requête :

* **Omis ou `{}`** : le dernier slot indexé, limité au niveau d'engagement demandé.
* **`{ "slot": 445000000 }`** : la fin du slot 445,000,000.
* **`{ "slot": 445000000, "transactionIndex": 10 }`** : immédiatement après l'exécution de la transaction d'index 10 dans ce slot.

Consultez le [guide des comptes historiques](https://www.helius.dev/docs/fr/rpc/historical-accounts.md) pour comprendre le fonctionnement des positions.

## Exemple de requête

Cette requête renvoie les comptes de jetons USDC du portefeuille à la fin du slot 445,000,000 :

```bash theme={"system"}
curl https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": "1",
    "method": "getHistoricalTokenAccountsByOwner",
    "params": [
      "86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY",
      { "slot": 445000000 },
      { "mint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", "encoding": "jsonParsed" }
    ]
  }'
```

## Parcourir tous les comptes de jetons avec la pagination

Les résultats sont triés d'abord par mint, puis par adresse de compte de jetons. Chaque réponse renvoie `value.accounts` et `value.paginationKey`, un curseur au format `<mint>:<tokenAccount>`. Transmettez-le dans la requête suivante jusqu'à ce qu'il soit égal à `null`.

> [!WARNING]
>
> Une page peut contenir peu de résultats, voire être vide, tout en incluant un `paginationKey`. Seul un `paginationKey` égal à `null` signifie que vous avez atteint la fin.

Transmettez toujours un `slot` explicite lorsque vous utilisez la pagination. Si vous l'omettez, chaque page lit le dernier slot indexé. Les pages peuvent donc provenir de différents moments.

```typescript theme={"system"}
const url = `https://mainnet.helius-rpc.com/?api-key=${process.env.HELIUS_API_KEY}`;

async function getTokenAccountsAt(owner: string, slot: number) {
  const accounts = [];
  let paginationKey: string | null = null;

  do {
    const response = await fetch(url, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        jsonrpc: "2.0",
        id: "1",
        method: "getHistoricalTokenAccountsByOwner",
        params: [
          owner,
          { slot },
          { encoding: "jsonParsed", limit: 1000, ...(paginationKey && { paginationKey }) },
        ],
      }),
    });
    const { result, error } = await response.json();
    if (error) throw new Error(`${error.code}: ${error.message}`);

    accounts.push(...result.value.accounts);
    paginationKey = result.value.paginationKey;
  } while (paginationKey);

  return accounts;
}

const tokenAccounts = await getTokenAccountsAt("86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY", 445000000);
```

## Lire la réponse

Chaque entrée de `value.accounts` contient le `pubkey` du compte de jetons et un objet `account`. L'objet du compte possède les mêmes champs que `getAccountInfo`, ainsi que `lastUpdatedAt` :

* **`lastUpdatedAt.slot`** et **`lastUpdatedAt.transactionIndex`** identifient l'écriture qui a produit cet état.
* **Un `lastUpdatedAt.slot` égal à 444,959,999 avec un `transactionIndex` égal à `null`** signifie que le compte de jetons n'a pas changé depuis le début de la couverture historique.
* **`context.slot`** est le dernier slot que Helius avait indexé au moment de traiter la requête, et non le slot interrogé.

## Erreurs

| Code | Signification |
| - | - |
| `-32018` | Le slot est antérieur au début de la couverture historique (slot 444,959,999) |
| `-32004` | Le slot est plus récent que ne l'autorise le niveau d'engagement demandé. Utilisez `confirmed` ou interrogez un slot plus ancien |
| `-32602` | Paramètres non valides, par exemple `mint` et `programId` définis simultanément, un `programId` qui n'est pas un programme de jetons, ou un `paginationKey` dont le mint ne correspond pas à `mint` |
| `-32601` | Méthode introuvable. Appelez votre endpoint mainnet Helius ou Gatekeeper ; la méthode n'est pas disponible sur le devnet |

## Méthodes associées

> [card] [Historical Accounts Guide](https://www.helius.dev/docs/fr/rpc/historical-accounts.md)
>
> Découvrez le fonctionnement des positions, de la couverture et de lastUpdatedAt pour les méthodes de comptes historiques

> [card] [getHistoricalAccountInfo](https://www.helius.dev/docs/fr/api-reference/rpc/http/gethistoricalaccountinfo.md)
>
> Lisez un compte unique à un slot passé

> [card] [getTransactionsForAddress](https://www.helius.dev/docs/fr/rpc/gettransactionsforaddress.md)
>
> Trouvez le slot et le transactionIndex des transactions que vous souhaitez examiner

> [card] [getTokenAccountsByOwnerV2](https://www.helius.dev/docs/fr/api-reference/rpc/http/gettokenaccountsbyownerv2.md)
>
> Parcourez les comptes de jetons actuels d'un portefeuille avec la pagination

## Paramètres de la requête

**owner** `string` *required*

Adresse encodée en base 58 du portefeuille qui possédait les comptes de jetons. Transmettez le portefeuille propriétaire, et non un compte de jetons.

**slot** `number`

Slot auquel lire l'état. Renvoie le compte tel qu'il était à la fin de ce slot. Le premier slot pris en charge est 444959999, soit l'état au début de l'époque 1030. Si ce paramètre est omis, lit le dernier slot indexé, limité au niveau d'engagement demandé.

**transactionIndex** `number`

Position d'une transaction dans le slot. Renvoie l'état du compte immédiatement après l'exécution de cette transaction, plutôt qu'à la fin du slot. Nécessite slot.

**mint** `string`

Renvoie uniquement les comptes de jetons correspondant à ce mint. Ne peut pas être combiné avec programId.

**programId** `string`

Renvoie uniquement les comptes de jetons détenus par ce programme de jetons. Ne peut pas être combiné avec mint.

* `TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA`
* `TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb`

**encoding** `string` (default: base64)

Format d'encodage des données du compte. Avec jsonParsed, les montants des jetons utilisent le nombre de décimales du mint à la position demandée. base58 et binary ne sont pas pris en charge.

* `base64`
* `base64+zstd`
* `jsonParsed`

**dataSlice** `object`

Renvoie uniquement une tranche des données de chaque compte. S'applique aux encodages base64 et base64+zstd.

**dataSlice.offset** `number` *required*

Décalage en octets à partir duquel commencer la lecture.

**dataSlice.length** `number` *required*

Nombre d'octets à renvoyer.

**limit** `number` (default: 5000)

Nombre maximal de comptes de jetons à renvoyer (1-5,000).

**paginationKey** `string`

Curseur provenant du paginationKey de la réponse précédente, au format `&lt;mint&gt;:&lt;tokenAccount&gt;`. Si vous définissez également mint, le mint du curseur doit lui correspondre.

**commitment** `string` (default: finalized)

Niveau d'engagement. processed n'est pas pris en charge.

* `finalized`
* `confirmed`

**minContextSlot** `number`

Slot minimal auquel la requête peut être évaluée.


## OpenAPI

````yaml fr/openapi/rpc-http/getHistoricalTokenAccountsByOwner.yaml POST /
openapi: 3.1.0
info:
  title: API RPC Solana
  version: 1.0.0
  description: >-
    API historique des comptes de jetons Solana permettant de répertorier les
    comptes SPL Token et Token-2022 détenus par un portefeuille à un slot
    antérieur, avec des filtres facultatifs par mint ou programme de jetons et
    une pagination basée sur un curseur.
  license:
    name: Apache 2.0
    url: https://www.apache.org/licenses/LICENSE-2.0.html
servers:
  - url: https://mainnet.helius-rpc.com
    description: Point de terminaison RPC du réseau principal
security: []
paths:
  /:
    post:
      tags:
        - RPC
      summary: getHistoricalTokenAccountsByOwner
      description: >
        **Bêta.** Les paramètres, les formats de réponse et la couverture des
        données sont susceptibles de changer.


        Renvoie les comptes SPL Token et Token-2022 détenus par un portefeuille
        à un slot antérieur, ou

        immédiatement après une transaction spécifique dans ce slot. Cette
        méthode RPC Helius

        renvoie tous les comptes de jetons par défaut. Limitez les résultats
        avec un mint ou un

        programId de programme de jetons dans l’objet de configuration.


        Les résultats sont triés par mint, puis par adresse de compte de jetons.
        Une page peut être courte ou

        vide tout en renvoyant une paginationKey ;

        continuez la pagination jusqu’à ce que paginationKey soit nulle.
      operationId: getHistoricalTokenAccountsByOwner
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - jsonrpc
                - id
                - method
                - params
              properties:
                jsonrpc:
                  type: string
                  enum:
                    - '2.0'
                  example: '2.0'
                  description: Version du protocole JSON-RPC.
                  default: '2.0'
                id:
                  type: string
                  example: '1'
                  description: Identifiant unique de la requête.
                  default: '1'
                method:
                  type: string
                  enum:
                    - getHistoricalTokenAccountsByOwner
                  example: getHistoricalTokenAccountsByOwner
                  description: Nom de la méthode RPC à appeler.
                  default: getHistoricalTokenAccountsByOwner
                params:
                  type: array
                  description: >-
                    Tableau contenant l’adresse du portefeuille propriétaire, un
                    objet de requête facultatif qui sélectionne la position dans
                    l’historique et un objet de configuration facultatif.
                  minItems: 1
                  maxItems: 3
                  default:
                    - 86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY
                    - slot: 445000000
                    - encoding: jsonParsed
                      limit: 2
                  items:
                    oneOf:
                      - type: string
                        title: Propriétaire
                        description: >-
                          Adresse encodée en base 58 du portefeuille qui
                          détenait les comptes de jetons. Transmettez le
                          portefeuille propriétaire, et non un compte de jetons.
                        example: 86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY
                      - $ref: '#/components/schemas/HistoricalAccountQuery'
                        title: Requête
                      - type: object
                        title: Configuration
                        description: >-
                          Objet de configuration facultatif. Définissez au
                          maximum l’un des deux paramètres mint ou programId.
                        properties:
                          mint:
                            type: string
                            description: >-
                              Renvoie uniquement les comptes de jetons
                              correspondant à ce mint. Ne peut pas être combiné
                              avec programId.
                            example: EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v
                          programId:
                            type: string
                            description: >-
                              Renvoie uniquement les comptes de jetons
                              appartenant à ce programme de jetons. Ne peut pas
                              être combiné avec mint.
                            enum:
                              - TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA
                              - TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb
                            example: TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA
                          encoding:
                            type: string
                            description: >-
                              Format d’encodage des données du compte. Avec
                              jsonParsed, les montants de jetons utilisent le
                              nombre de décimales du mint à la position
                              demandée. base58 et binary ne sont pas pris en
                              charge.
                            enum:
                              - base64
                              - base64+zstd
                              - jsonParsed
                            default: base64
                            example: jsonParsed
                          dataSlice:
                            $ref: '#/components/schemas/DataSliceConfig'
                          limit:
                            type: integer
                            description: >-
                              Nombre maximal de comptes de jetons à renvoyer
                              (1-5 000).
                            minimum: 1
                            maximum: 5000
                            default: 5000
                            example: 1000
                          paginationKey:
                            type: string
                            description: >-
                              Curseur provenant de la paginationKey de la
                              réponse précédente, au format
                              `<mint>:<tokenAccount>`. Si vous définissez
                              également mint, le mint du curseur doit lui
                              correspondre.
                            example: >-
                              11112zAgXhc6hGfdfr5anSY91mq7Cs4HHpSVEQc4ASG:EKyGnXReqmmXyqBHmMjV2CKCLafJS47xyhXXZ5WuFMxD
                          commitment:
                            type: string
                            description: >-
                              Niveau d’engagement. processed n’est pas pris en
                              charge.
                            enum:
                              - finalized
                              - confirmed
                            default: finalized
                            example: finalized
                          minContextSlot:
                            type: integer
                            description: Slot minimal auquel la requête peut être évaluée.
                            example: 445000000
                        additionalProperties: false
      responses:
        '200':
          description: Une page de comptes de jetons historiques a été récupérée.
          content:
            application/json:
              schema:
                type: object
                properties:
                  jsonrpc:
                    type: string
                    description: Version du protocole JSON-RPC.
                    enum:
                      - '2.0'
                    example: '2.0'
                  id:
                    type: string
                    description: Identifiant correspondant à la requête.
                    example: '1'
                  result:
                    type: object
                    properties:
                      context:
                        $ref: '#/components/schemas/HistoricalContext'
                      value:
                        type: object
                        properties:
                          accounts:
                            type: array
                            description: >-
                              Comptes de jetons de cette page, triés par mint,
                              puis par adresse de compte de jetons.
                            items:
                              $ref: '#/components/schemas/HistoricalKeyedAccount'
                          paginationKey:
                            oneOf:
                              - type: string
                              - type: 'null'
                            description: >-
                              Curseur de la page suivante, au format
                              `<mint>:<tokenAccount>`, ou null une fois tous les
                              comptes renvoyés. Une page courte ou vide
                              contenant une paginationKey signifie que l’analyse
                              s’est arrêtée prématurément, et non que vous avez
                              atteint la fin.
                            example: >-
                              11112zAgXhc6hGfdfr5anSY91mq7Cs4HHpSVEQc4ASG:EKyGnXReqmmXyqBHmMjV2CKCLafJS47xyhXXZ5WuFMxD
        '400':
          description: >-
            Requête incorrecte - Paramètres de requête non valides ou requête
            mal formée.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                jsonrpc: '2.0'
                error:
                  code: -32602
                  message: Paramètres non valides
                id: '1'
        '401':
          description: Non autorisé - Clé API non valide ou manquante.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                jsonrpc: '2.0'
                error:
                  code: -32001
                  message: Non autorisé
                id: '1'
        '429':
          description: Trop de requêtes - Limite de débit dépassée.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                jsonrpc: '2.0'
                error:
                  code: -32005
                  message: Trop de requêtes
                id: '1'
        '500':
          description: >-
            Erreur interne du serveur - Une erreur s’est produite sur le
            serveur.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                jsonrpc: '2.0'
                error:
                  code: -32603
                  message: Erreur interne
                id: '1'
        '503':
          description: Service indisponible - Le service est temporairement indisponible.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                jsonrpc: '2.0'
                error:
                  code: -32002
                  message: Service indisponible
                id: '1'
        '504':
          description: Délai d’attente de la passerelle dépassé - La requête a expiré.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                jsonrpc: '2.0'
                error:
                  code: -32003
                  message: Délai d’attente de la passerelle dépassé
                id: '1'
      security:
        - ApiKeyQuery: []
components:
  schemas:
    HistoricalAccountQuery:
      type: object
      description: >-
        Position dans l’historique à lire. Omettez-la ou envoyez un objet vide
        pour lire le dernier slot indexé.
      properties:
        slot:
          type: integer
          description: >-
            Slot auquel lire l’état. Renvoie le compte tel qu’il était à la fin
            de ce slot. Le premier slot pris en charge est 444959999, soit
            l’état au début de l’époque 1030. Si cette valeur est omise, lit le
            dernier slot indexé, limité au niveau d’engagement demandé.
          minimum: 444959999
          example: 445000000
        transactionIndex:
          type: integer
          description: >-
            Position d’une transaction dans le slot. Renvoie l’état du compte
            immédiatement après l’exécution de cette transaction, plutôt qu’à la
            fin du slot. Nécessite slot.
          minimum: 0
          maximum: 16777214
          example: 10
      additionalProperties: false
    DataSliceConfig:
      type: object
      description: >-
        Renvoie uniquement une portion des données de chaque compte. S’applique
        aux encodages base64 et base64+zstd.
      properties:
        offset:
          type: integer
          description: Décalage en octets à partir duquel commencer la lecture.
          example: 0
        length:
          type: integer
          description: Nombre d’octets à renvoyer.
          example: 8
      required:
        - offset
        - length
    HistoricalContext:
      type: object
      description: Métadonnées de la réponse.
      properties:
        slot:
          type: integer
          description: >-
            Dernier slot que le stockage d’historique avait indexé lors du
            traitement de la requête. Il ne s’agit pas du slot que vous avez
            interrogé.
          example: 468129571
    HistoricalKeyedAccount:
      type: object
      properties:
        pubkey:
          type: string
          description: Adresse encodée en base 58 du compte de jetons.
          example: EKyGnXReqmmXyqBHmMjV2CKCLafJS47xyhXXZ5WuFMxD
        account:
          $ref: '#/components/schemas/HistoricalAccount'
      required:
        - pubkey
        - account
    ErrorResponse:
      type: object
      properties:
        jsonrpc:
          type: string
          description: Version du protocole JSON-RPC.
          enum:
            - '2.0'
          example: '2.0'
        error:
          type: object
          properties:
            code:
              type: integer
              description: Code de l’erreur.
              example: -32602
            message:
              type: string
              description: Message d’erreur.
            data:
              type: object
              description: Données supplémentaires sur l’erreur.
        id:
          type: string
          description: Identifiant correspondant à la requête.
          example: '1'
    HistoricalAccount:
      type: object
      description: >-
        Compte tel qu’il était à la position demandée, accompagné de
        l’emplacement où cet état a été écrit pour la dernière fois.
      properties:
        lamports:
          type: integer
          description: Nombre de lamports attribués à ce compte.
          example: 531589475273
        owner:
          type: string
          description: >-
            Clé publique encodée en base 58 du programme auquel ce compte a été
            attribué.
          example: TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA
        data:
          description: >-
            Données du compte. Avec base64 ou base64+zstd, il s’agit d’un
            tableau de deux éléments contenant les données encodées et
            l’encodage. Avec jsonParsed, il s’agit d’un objet contenant program,
            parsed et space. Les comptes qui ne peuvent pas être analysés
            utilisent à la place le tableau base64.
          oneOf:
            - type: array
              items:
                type: string
            - type: object
              properties:
                program:
                  type: string
                  description: Nom du programme propriétaire du compte.
                  example: spl-token
                parsed:
                  type: object
                  description: État analysé du compte propre au programme.
                space:
                  type: integer
                  description: Taille des données du compte.
                  example: 82
        executable:
          type: boolean
          description: Indique si le compte contient un programme.
          example: false
        rentEpoch:
          type: integer
          description: >-
            Époque à laquelle ce compte devra de nouveau payer un loyer. Les
            comptes exonérés de loyer indiquent la valeur u64 maximale.
        space:
          type: integer
          description: Taille des données du compte en octets.
          example: 82
        lastUpdatedAt:
          $ref: '#/components/schemas/AccountWritePosition'
      required:
        - lamports
        - owner
        - data
        - executable
        - rentEpoch
        - space
        - lastUpdatedAt
    AccountWritePosition:
      type: object
      description: >-
        Emplacement où l’état renvoyé a été écrit pour la dernière fois, à la
        position demandée ou avant celle-ci.
      properties:
        slot:
          type: integer
          description: >-
            Slot de la dernière écriture. Une valeur de 444959999 avec un
            transactionIndex nul signifie que le compte n’a pas changé depuis le
            début de la couverture de l’historique.
          example: 444999837
        transactionIndex:
          oneOf:
            - type: integer
            - type: 'null'
          description: >-
            Position de la transaction ayant effectué la dernière écriture.
            Nulle lorsque l’écriture a eu lieu en dehors d’une transaction (par
            exemple, pour les récompenses d’époque), ou lorsque le compte n’a
            pas changé depuis le début de la couverture de l’historique.
          example: 700
      required:
        - slot
        - transactionIndex
  securitySchemes:
    ApiKeyQuery:
      type: apiKey
      in: query
      name: api-key
      description: >-
        Votre clé API Helius. Vous pouvez en obtenir une gratuitement dans le
        [tableau de bord](https://dashboard.helius.dev/api-keys).

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.