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

> Liste die SPL-Token- und Token-2022-Konten auf, die einer Solana-Wallet bei einem früheren slot oder direkt nach einer bestimmten Transaktion gehörten. Unterstützt Mint-Filter und Seitennavigation.

> [!NOTE]
>
> `getHistoricalTokenAccountsByOwner` befindet sich in der Betaphase. Parameter, Preise, response-Formate und Datenabdeckung können sich ändern.

## Übersicht

`getHistoricalTokenAccountsByOwner` gibt die SPL-Token- und Token-2022-Konten zurück, die einer Wallet bei einem früheren slot oder unmittelbar nach einer bestimmten Transaktion in diesem slot gehörten. Diese RPC-Methode ist exklusiv bei Helius verfügbar. Die standardmäßige Methode `getTokenAccountsByOwner` gibt nur den aktuellen Zustand zurück.

Bei der Kodierung `jsonParsed` verwenden Token-Beträge die Dezimalstellen des jeweiligen Mint an der angefragten Position. Die Guthaben spiegeln somit wider, was die Wallet zu diesem Zeitpunkt hielt.

Der Verlauf ist ab slot 444.959.999 (7. September 2026) verfügbar. Dies entspricht dem Zustand zu Beginn von Epoche 1030.

`getHistoricalTokenAccountsByOwner` ist im mainnet für Business-Tarife und höher verfügbar. Während der Betaphase kostet jeder Aufruf 0 Credits. Die Preise können sich ändern.

## Unterschiede zu getTokenAccountsByOwner

* **Der Mint- oder Programmfilter ist optional.** Ohne Filter erhältst du alle Token-Konten, die der Wallet gehörten. Um die Ergebnisse einzugrenzen, lege entweder `mint` oder `programId` im Konfigurationsobjekt (dem dritten Parameter) fest, aber nicht beides.
* **Der zweite Parameter ist das Abfrageobjekt**, das die Position im Verlauf auswählt, und kein Mint- oder Programmfilter.
* **`result.value` ist ein Objekt** mit `accounts` und `paginationKey`, kein Array.

## Position im Verlauf auswählen

Der zweite Parameter ist ein Abfrageobjekt:

* **Weggelassen oder `{}`**: der neueste indexierte slot, begrenzt durch das angefragte commitment.
* **`{ "slot": 445000000 }`**: das Ende von slot 445.000.000.
* **`{ "slot": 445000000, "transactionIndex": 10 }`**: unmittelbar nachdem die Transaktion mit Index 10 in diesem slot ausgeführt wurde.

Im [Leitfaden zu historischen Konten](https://www.helius.dev/docs/de/rpc/historical-accounts.md) erfährst du, wie Positionen funktionieren.

## Beispiel-request

Dieser request gibt die USDC-Token-Konten der Wallet am Ende von slot 445.000.000 zurück:

```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" }
    ]
  }'
```

## Durch alle Token-Konten blättern

Die Ergebnisse werden zuerst nach Mint und dann nach der Adresse des Token-Kontos sortiert. Jede response gibt `value.accounts` und `value.paginationKey` zurück. Letzteres ist ein Cursor im Format `<mint>:<tokenAccount>`. Übergib ihn im nächsten request erneut, bis er `null` ist.

> [!WARNING]
>
> Eine Seite kann kurz oder sogar leer sein und trotzdem `paginationKey` enthalten. Erst wenn `paginationKey` den Wert `null` hat, hast du das Ende erreicht.

Übergib bei der Seitennavigation immer explizit `slot`. Wenn du den Wert weglässt, liest jede Seite den neuesten indexierten slot. Die Seiten können dann von unterschiedlichen Zeitpunkten stammen.

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

## response lesen

Jeder Eintrag in `value.accounts` enthält `pubkey` des Token-Kontos und ein `account`-Objekt. Das Kontoobjekt hat dieselben Felder wie `getAccountInfo` sowie `lastUpdatedAt`:

* **`lastUpdatedAt.slot`** und **`lastUpdatedAt.transactionIndex`** identifizieren den Schreibvorgang, der diesen Zustand erzeugt hat.
* **Ein `lastUpdatedAt.slot` von 444.959.999 mit einem `null`-Wert für `transactionIndex`** bedeutet, dass sich das Token-Konto seit Beginn der Verlaufsabdeckung nicht geändert hat.
* **`context.slot`** ist der neueste slot, den Helius beim Verarbeiten des request indexiert hatte, nicht der von dir abgefragte slot.

## Fehler

| Code | Bedeutung |
| - | - |
| `-32018` | Der slot liegt vor dem Beginn der Verlaufsabdeckung (slot 444.959.999) |
| `-32004` | Der slot ist neuer, als es das angefragte commitment erlaubt. Verwende `confirmed` oder frage einen älteren slot ab |
| `-32602` | Ungültige Parameter, zum Beispiel sowohl `mint` als auch `programId`, ein `programId`, das kein Token-Programm ist, oder ein `paginationKey`, dessen Mint nicht mit `mint` übereinstimmt |
| `-32601` | Methode nicht gefunden. Rufe deinen Helius-mainnet- oder Gatekeeper-endpoint auf. Die Methode ist im devnet nicht verfügbar |

## Zugehörige Methoden

> [card] [Historical Accounts Guide](https://www.helius.dev/docs/de/rpc/historical-accounts.md)
>
> So funktionieren Positionen, Abdeckung und lastUpdatedAt bei Methoden für historische Konten

> [card] [getHistoricalAccountInfo](https://www.helius.dev/docs/de/api-reference/rpc/http/gethistoricalaccountinfo.md)
>
> Lies ein einzelnes Konto bei einem früheren slot

> [card] [getTransactionsForAddress](https://www.helius.dev/docs/de/rpc/gettransactionsforaddress.md)
>
> Finde slot und transactionIndex der Transaktionen, die du untersuchen möchtest

> [card] [getTokenAccountsByOwnerV2](https://www.helius.dev/docs/de/api-reference/rpc/http/gettokenaccountsbyownerv2.md)
>
> Blättere durch die aktuellen Token-Konten einer Wallet

## request-Parameter

**owner** `string` *required*

Base-58-kodierte Adresse der Wallet, der die Token-Konten gehörten. Übergib die Wallet des Inhabers, nicht ein Token-Konto.

**slot** `number`

slot, dessen Zustand gelesen werden soll. Gibt das Konto am Ende dieses slot zurück. Der früheste unterstützte slot ist 444959999. Dies entspricht dem Zustand zu Beginn von Epoche 1030. Wenn du den Wert weglässt, wird der neueste indexierte slot gelesen, begrenzt durch das angefragte commitment.

**transactionIndex** `number`

Position einer Transaktion innerhalb des slot. Gibt den Kontozustand unmittelbar nach Ausführung dieser Transaktion zurück, statt am Ende des slot. Erfordert slot.

**mint** `string`

Gibt nur Token-Konten für diesen Mint zurück. Kann nicht mit programId kombiniert werden.

**programId** `string`

Gibt nur Token-Konten zurück, die diesem Token-Programm gehören. Kann nicht mit mint kombiniert werden.

* `TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA`
* `TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb`

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

Kodierungsformat für Kontodaten. Bei jsonParsed verwenden Token-Beträge die Dezimalstellen des Mint an der angefragten Position. base58 und binary werden nicht unterstützt.

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

**dataSlice** `object`

Gibt nur einen Ausschnitt der Daten jedes Kontos zurück. Gilt für die Kodierungen base64 und base64+zstd.

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

Byte-Offset, ab dem gelesen werden soll.

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

Anzahl der zurückzugebenden Bytes.

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

Maximale Anzahl der zurückzugebenden Token-Konten (1–5.000).

**paginationKey** `string`

Cursor aus paginationKey der vorherigen response im Format `&lt;mint&gt;:&lt;tokenAccount&gt;`. Wenn du außerdem mint festlegst, muss der Mint des Cursor damit übereinstimmen.

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

Stufe für commitment. processed wird nicht unterstützt.

* `finalized`
* `confirmed`

**minContextSlot** `number`

Der minimale slot, bei dem der request ausgewertet werden kann.


## OpenAPI

````yaml de/openapi/rpc-http/getHistoricalTokenAccountsByOwner.yaml POST /
openapi: 3.1.0
info:
  title: Solana RPC API
  version: 1.0.0
  description: >-
    Historische Solana-API für token accounts. Listet die SPL Token- und
    Token-2022-Konten auf, die eine Wallet an einem früheren slot besaß.
    Unterstützt optionale Filter nach Mint oder token-Programm sowie
    cursorbasierte Paginierung.
  license:
    name: Apache 2.0
    url: https://www.apache.org/licenses/LICENSE-2.0.html
servers:
  - url: https://mainnet.helius-rpc.com
    description: Mainnet-RPC-endpoint
security: []
paths:
  /:
    post:
      tags:
        - RPC
      summary: getHistoricalTokenAccountsByOwner
      description: >
        **Beta.** Parameter, response-Formate und Datenabdeckung können sich
        ändern.


        Gibt die SPL Token- und Token-2022-Konten zurück, die eine Wallet an
        einem früheren slot

        oder unmittelbar nach einer bestimmten Transaktion innerhalb dieses slot
        besaß. Diese Helius-RPC-Methode

        gibt standardmäßig jedes token account zurück. Grenze die Ergebnisse im
        Konfigurationsobjekt

        entweder mit einem Mint oder einer token-programId ein.


        Die Ergebnisse sind zuerst nach Mint und dann nach der Adresse des token
        account sortiert. Eine Seite kann kurz oder

        leer sein und trotzdem einen paginationKey zurückgeben;

        rufe weitere Seiten ab, bis paginationKey null ist.
      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: Die Version des JSON-RPC-Protokolls.
                  default: '2.0'
                id:
                  type: string
                  example: '1'
                  description: Eine eindeutige Kennung für den request.
                  default: '1'
                method:
                  type: string
                  enum:
                    - getHistoricalTokenAccountsByOwner
                  example: getHistoricalTokenAccountsByOwner
                  description: Der Name der aufzurufenden RPC-Methode.
                  default: getHistoricalTokenAccountsByOwner
                params:
                  type: array
                  description: >-
                    Array mit der Wallet-Adresse des Eigentümers, einem
                    optionalen Abfrageobjekt zur Auswahl der Position im Verlauf
                    und einem optionalen Konfigurationsobjekt.
                  minItems: 1
                  maxItems: 3
                  default:
                    - 86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY
                    - slot: 445000000
                    - encoding: jsonParsed
                      limit: 2
                  items:
                    oneOf:
                      - type: string
                        title: Eigentümer
                        description: >-
                          Base-58-codierte Adresse der Wallet, der die token
                          accounts gehörten. Übergib die Wallet des Eigentümers,
                          nicht die Adresse eines token account.
                        example: 86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY
                      - $ref: '#/components/schemas/HistoricalAccountQuery'
                        title: Abfrage
                      - type: object
                        title: Konfiguration
                        description: >-
                          Optionales Konfigurationsobjekt. Lege höchstens einen
                          der Werte mint oder programId fest.
                        properties:
                          mint:
                            type: string
                            description: >-
                              Gibt nur token accounts für diesen Mint zurück.
                              Kann nicht mit programId kombiniert werden.
                            example: EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v
                          programId:
                            type: string
                            description: >-
                              Gibt nur token accounts zurück, die diesem
                              token-Programm gehören. Kann nicht mit mint
                              kombiniert werden.
                            enum:
                              - TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA
                              - TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb
                            example: TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA
                          encoding:
                            type: string
                            description: >-
                              Codierungsformat für Kontodaten. Bei jsonParsed
                              verwenden token-Beträge die Dezimalstellen des
                              Mint an der angeforderten Position. base58 und
                              binary werden nicht unterstützt.
                            enum:
                              - base64
                              - base64+zstd
                              - jsonParsed
                            default: base64
                            example: jsonParsed
                          dataSlice:
                            $ref: '#/components/schemas/DataSliceConfig'
                          limit:
                            type: integer
                            description: >-
                              Maximale Anzahl der zurückzugebenden token
                              accounts (1–5.000).
                            minimum: 1
                            maximum: 5000
                            default: 5000
                            example: 1000
                          paginationKey:
                            type: string
                            description: >-
                              Cursor aus dem paginationKey der vorherigen
                              response im Format `<mint>:<tokenAccount>`. Wenn
                              du auch mint festlegst, muss der Mint des Cursors
                              damit übereinstimmen.
                            example: >-
                              11112zAgXhc6hGfdfr5anSY91mq7Cs4HHpSVEQc4ASG:EKyGnXReqmmXyqBHmMjV2CKCLafJS47xyhXXZ5WuFMxD
                          commitment:
                            type: string
                            description: >-
                              commitment-Stufe. processed wird nicht
                              unterstützt.
                            enum:
                              - finalized
                              - confirmed
                            default: finalized
                            example: finalized
                          minContextSlot:
                            type: integer
                            description: >-
                              Der minimale slot, an dem der request ausgewertet
                              werden kann.
                            example: 445000000
                        additionalProperties: false
      responses:
        '200':
          description: >-
            Eine Seite mit historischen token accounts wurde erfolgreich
            abgerufen.
          content:
            application/json:
              schema:
                type: object
                properties:
                  jsonrpc:
                    type: string
                    description: Die Version des JSON-RPC-Protokolls.
                    enum:
                      - '2.0'
                    example: '2.0'
                  id:
                    type: string
                    description: Kennung, die dem request entspricht.
                    example: '1'
                  result:
                    type: object
                    properties:
                      context:
                        $ref: '#/components/schemas/HistoricalContext'
                      value:
                        type: object
                        properties:
                          accounts:
                            type: array
                            description: >-
                              token accounts auf dieser Seite, zuerst nach Mint
                              und dann nach der Adresse des token account
                              sortiert.
                            items:
                              $ref: '#/components/schemas/HistoricalKeyedAccount'
                          paginationKey:
                            oneOf:
                              - type: string
                              - type: 'null'
                            description: >-
                              Cursor für die nächste Seite im Format
                              `<mint>:<tokenAccount>` oder null, sobald alle
                              Konten zurückgegeben wurden. Eine kurze oder leere
                              Seite mit einem paginationKey bedeutet, dass der
                              Scan vorzeitig beendet wurde, nicht dass du das
                              Ende erreicht hast.
                            example: >-
                              11112zAgXhc6hGfdfr5anSY91mq7Cs4HHpSVEQc4ASG:EKyGnXReqmmXyqBHmMjV2CKCLafJS47xyhXXZ5WuFMxD
        '400':
          description: >-
            Ungültiger request – Ungültige request-Parameter oder fehlerhaft
            formatierter request.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                jsonrpc: '2.0'
                error:
                  code: -32602
                  message: Invalid params
                id: '1'
        '401':
          description: Nicht autorisiert – Ungültiger oder fehlender API key.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                jsonrpc: '2.0'
                error:
                  code: -32001
                  message: Unauthorized
                id: '1'
        '429':
          description: Zu viele requests – rate limit überschritten.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                jsonrpc: '2.0'
                error:
                  code: -32005
                  message: Too many requests
                id: '1'
        '500':
          description: Interner Serverfehler – Auf dem Server ist ein Fehler aufgetreten.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                jsonrpc: '2.0'
                error:
                  code: -32603
                  message: Internal error
                id: '1'
        '503':
          description: >-
            Dienst nicht verfügbar – Der Dienst ist vorübergehend nicht
            verfügbar.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                jsonrpc: '2.0'
                error:
                  code: -32002
                  message: Service unavailable
                id: '1'
        '504':
          description: Gateway-timeout – Für den request ist ein timeout aufgetreten.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                jsonrpc: '2.0'
                error:
                  code: -32003
                  message: Gateway timeout
                id: '1'
      security:
        - ApiKeyQuery: []
components:
  schemas:
    HistoricalAccountQuery:
      type: object
      description: >-
        Die Position im Verlauf, aus der gelesen werden soll. Lass sie weg oder
        sende ein leeres Objekt, um den neuesten indizierten slot zu lesen.
      properties:
        slot:
          type: integer
          description: >-
            slot, an dem der Zustand gelesen wird. Gibt das Konto mit dem Stand
            am Ende dieses slot zurück. Der früheste unterstützte slot ist
            444959999, der Zustand zu Beginn der Epoche 1030. Wenn du ihn
            weglässt, wird der neueste indizierte slot gelesen, begrenzt auf das
            angeforderte commitment.
          minimum: 444959999
          example: 445000000
        transactionIndex:
          type: integer
          description: >-
            Position einer Transaktion innerhalb des slot. Gibt den Kontostand
            unmittelbar nach Ausführung dieser Transaktion statt am Ende des
            slot zurück. Erfordert slot.
          minimum: 0
          maximum: 16777214
          example: 10
      additionalProperties: false
    DataSliceConfig:
      type: object
      description: >-
        Gibt nur einen Ausschnitt der Daten jedes Kontos zurück. Gilt für die
        Codierungen base64 und base64+zstd.
      properties:
        offset:
          type: integer
          description: Byte-Offset, ab dem gelesen wird.
          example: 0
        length:
          type: integer
          description: Anzahl der zurückzugebenden Bytes.
          example: 8
      required:
        - offset
        - length
    HistoricalContext:
      type: object
      description: Metadaten der response.
      properties:
        slot:
          type: integer
          description: >-
            Der neueste slot, den der Verlaufsspeicher indiziert hatte, als er
            den request beantwortete. Dies ist nicht der von dir abgefragte
            slot.
          example: 468129571
    HistoricalKeyedAccount:
      type: object
      properties:
        pubkey:
          type: string
          description: Base-58-codierte Adresse des token account.
          example: EKyGnXReqmmXyqBHmMjV2CKCLafJS47xyhXXZ5WuFMxD
        account:
          $ref: '#/components/schemas/HistoricalAccount'
      required:
        - pubkey
        - account
    ErrorResponse:
      type: object
      properties:
        jsonrpc:
          type: string
          description: Die Version des JSON-RPC-Protokolls.
          enum:
            - '2.0'
          example: '2.0'
        error:
          type: object
          properties:
            code:
              type: integer
              description: Der Fehlercode.
              example: -32602
            message:
              type: string
              description: Die Fehlermeldung.
            data:
              type: object
              description: Zusätzliche Daten zum Fehler.
        id:
          type: string
          description: Kennung, die dem request entspricht.
          example: '1'
    HistoricalAccount:
      type: object
      description: >-
        Das Konto mit dem Stand an der angeforderten Position sowie die
        Position, an der dieser Zustand zuletzt geschrieben wurde.
      properties:
        lamports:
          type: integer
          description: Anzahl der diesem Konto zugewiesenen Lamports.
          example: 531589475273
        owner:
          type: string
          description: >-
            Base-58-codierter öffentlicher Schlüssel des Programms, dem dieses
            Konto zugewiesen wurde.
          example: TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA
        data:
          description: >-
            Kontodaten. Bei base64 oder base64+zstd ist dies ein Array mit zwei
            Elementen: den codierten Daten und der Codierung. Bei jsonParsed ist
            es ein Objekt mit program, parsed und space. Konten, die nicht
            geparst werden können, verwenden stattdessen das base64-Array.
          oneOf:
            - type: array
              items:
                type: string
            - type: object
              properties:
                program:
                  type: string
                  description: Name des Programms, dem das Konto gehört.
                  example: spl-token
                parsed:
                  type: object
                  description: Programmspezifisch geparster Kontostand.
                space:
                  type: integer
                  description: Datengröße des Kontos.
                  example: 82
        executable:
          type: boolean
          description: Gibt an, ob das Konto ein Programm enthält.
          example: false
        rentEpoch:
          type: integer
          description: >-
            Die Epoche, in der für dieses Konto das nächste Mal Miete fällig
            wird. Mietbefreite Konten geben den maximalen u64-Wert zurück.
        space:
          type: integer
          description: Datengröße des Kontos in Byte.
          example: 82
        lastUpdatedAt:
          $ref: '#/components/schemas/AccountWritePosition'
      required:
        - lamports
        - owner
        - data
        - executable
        - rentEpoch
        - space
        - lastUpdatedAt
    AccountWritePosition:
      type: object
      description: >-
        Position, an oder vor der der angeforderte Zustand zuletzt geschrieben
        wurde.
      properties:
        slot:
          type: integer
          description: >-
            slot des letzten Schreibvorgangs. Der Wert 444959999 mit einem
            transactionIndex von null bedeutet, dass sich das Konto seit Beginn
            der Verlaufsabdeckung nicht geändert hat.
          example: 444999837
        transactionIndex:
          oneOf:
            - type: integer
            - type: 'null'
          description: >-
            Position der Transaktion, die den letzten Schreibvorgang ausgeführt
            hat. Null, wenn der Schreibvorgang außerhalb einer Transaktion
            stattfand, beispielsweise bei Epochen-Belohnungen, oder wenn sich
            das Konto seit Beginn der Verlaufsabdeckung nicht geändert hat.
          example: 700
      required:
        - slot
        - transactionIndex
  securitySchemes:
    ApiKeyQuery:
      type: apiKey
      in: query
      name: api-key
      description: >-
        Dein Helius API key. Du kannst ihn kostenlos im
        [Dashboard](https://dashboard.helius.dev/api-keys) abrufen.

````

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