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

# getTransactionsForAddress Übersicht und Tutorial

> Erfahren Sie, wie Sie die Solana-Transaktionshistorie mit fortschrittlicher Filterung, bidirektionaler Sortierung und effizienter Paginierung unter Verwendung dieser exklusiven Helius-RPC-Methode abfragen können.

## Übersicht

[`getTransactionsForAddress`](/docs/de/api-reference/rpc/http/gettransactionsforaddress) ist eine exklusive Helius-RPC-Methode, die die Transaktionshistorie einer Adresse mit fortschrittlicher Filterung, flexibler Sortierung und effizienter Paginierung zurückgibt. Es ist nicht Teil des standardmäßigen Solana-RPC.

Im Gegensatz zu `getSignaturesForAddress`, das nur Signaturen zurückgibt und zugehörige Token-Konten überspringt, kann `getTransactionsForAddress` vollständige Transaktionsdaten zurückgeben, einschließlich der Aktivität eines Wallets im zugehörigen Token-Konto (ATA), in einem einzigen Aufruf. Das macht es zum schnellsten Weg, um eine vollständige Adresshistorie für Backfilling, Indexierung und Analysen zu erhalten.

Diese Methode gibt bis zu 1.000 vollständige Transaktionen pro Aufruf zurück.

<CardGroup cols={2}>
  <Card title="Flexible Sortierung" icon="arrows-up-down">
    Chronologisch (älteste zuerst) oder umgekehrt (neueste zuerst) sortieren.
  </Card>

  <Card title="Fortschrittliche Filterung" icon="filter">
    Nach Zeitbereichen, Slots, Signaturen, Status und Token-Transfers filtern.
  </Card>

  <Card title="Vollständige Transaktionsdaten" icon="database">
    Erhalten Sie vollständige Transaktionsdetails in einem Aufruf, kein Folgeaufruf von getTransaction nötig.
  </Card>

  <Card title="Token-Konten" icon="layer-group">
    Transaktionen für die zugehörigen Token-Konten einer Adresse einbeziehen.
  </Card>
</CardGroup>

## Wann man dies benutzt

Verwenden Sie `getTransactionsForAddress`, wenn Sie benötigen:

* Vollständige Wallet-Token-Historie, einschließlich zugehöriger Token-Konten
* Ein schnelles Single-Call-Backfill für einen Indexer oder eine Datenpipeline
* Zeitbasierte oder Slot-basierte Transaktionsanalyse und Berichterstellung
* Statusfilterung, um nur erfolgreiche oder nur fehlgeschlagene Transaktionen beizubehalten
* Chronologische historische Wiedergabe (älteste zuerst Sortierung)
* Token-Startanalyse: erste Prägungstransaktionen und frühe Halter
* Wallet-Finanzierungshistorie und Kontrahentenerkennung
* Compliance- und Prüfberichte für einen bestimmten Zeitraum

Für eine analysierte, nur auf Übertragungen basierende Historie (Zahlungen, Saldenabgleich) verwenden Sie stattdessen [`getTransfersByAddress`](/docs/de/rpc/gettransfersbyaddress).

### Netzwerkunterstützung

| Netzwerk | Unterstützt | Aufbewahrungszeitraum |
| -------- | ----------- | --------------------- |
| Mainnet  | Ja          | Unbegrenzt            |
| Devnet   | Ja          | 2 Wochen              |
| Testnet  | Nein        | N/A                   |

## Schnellstart

<Steps>
  <Step title="Holen Sie sich Ihren API-Schlüssel">
    Holen Sie sich Ihren API-Schlüssel vom [Helius Dashboard](https://dashboard.helius.dev/api-keys).
  </Step>

  <Step title="Abfrage mit erweiterten Funktionen">
    Holen Sie sich alle erfolgreichen Transaktionen für ein Wallet zwischen zwei Daten, chronologisch sortiert:

    ```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="Verstehen der Parameter">
    Dieses Beispiel zeigt die Schlüsselmerkmale:

    * **transactionDetails**: auf `'full'` setzen, um vollständige Transaktionsdaten in einem Aufruf zu erhalten
    * **sortOrder**: verwenden Sie `'asc'` für chronologische Reihenfolge (älteste zuerst) oder `'desc'` für die neuesten zuerst
    * **filters.blockTime**: Zeitbereiche mit `gte` (größer oder gleich) und `lte` (kleiner oder gleich) festlegen
    * **filters.status**: filtern, um nur `'succeeded'` oder `'failed'` Transaktionen zu behalten
    * **filters.tokenAccounts**: Transfers, Prägungen und Verbrennungen für zugehörige Token-Konten einbeziehen
  </Step>
</Steps>

## Anforderungsparameter

<ParamField body="address" type="string" required>
  Base-58 kodierter öffentlicher Schlüssel des Kontos, für das die Transaktionshistorie abgefragt werden soll
</ParamField>

<ParamField body="transactionDetails" type="string" default="signatures">
  Detailebene der zurückzugebenden Transaktionen:

  * `signatures`: Basis-Signaturinformationen (schneller)
  * `full`: Vollständige Transaktionsdaten (eliminiert den Bedarf an getTransaction-Aufrufen, unterstützt Limit bis zu 1.000)
</ParamField>

<ParamField body="sortOrder" type="string" default="desc">
  Sortierreihenfolge für Ergebnisse:

  * `desc`: Neueste zuerst (Standard)
  * `asc`: Älteste zuerst (chronologisch, ideal für historische Analysen)
</ParamField>

<ParamField body="limit" type="number" default="1000">
  Maximale Anzahl von Transaktionen zur Rückgabe:

  * Bis zu 1000, wenn `transactionDetails: "signatures"`
  * Bis zu 1000, wenn `transactionDetails: "full"`
</ParamField>

<ParamField body="paginationToken" type="string">
  Paginierungstoken aus vorheriger Antwort (Format: `"slot:position"`)
</ParamField>

<ParamField body="commitment" type="string" default="finalized">
  Commitment-Level: `finalized` oder `confirmed`. Das `processed`-Commitment wird nicht unterstützt.
</ParamField>

<ParamField body="filters" type="object">
  Erweiterte Filteroptionen zur Eingrenzung der Ergebnisse.
</ParamField>

<ParamField body="filters.slot" type="object">
  Nach Slotnummer mit Vergleichsoperatoren filtern: `gte`, `gt`, `lte`, `lt`

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

<ParamField body="filters.blockTime" type="object">
  Nach Unix-Zeitstempel mit Vergleichsoperatoren filtern: `gte`, `gt`, `lte`, `lt`, `eq`

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

<ParamField body="filters.signature" type="object">
  Nach Transaktionssignatur mit Vergleichsoperatoren filtern: `gte`, `gt`, `lte`, `lt`

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

<ParamField body="filters.status" type="string">
  Nach Erfolg/Misserfolg-Status der Transaktion filtern:

  * `succeeded`: Nur erfolgreiche Transaktionen
  * `failed`: Nur fehlgeschlagene Transaktionen
  * `any`: Sowohl erfolgreiche als auch fehlgeschlagene (Standard)

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

<ParamField body="filters.tokenAccounts" type="string" default="none">
  Transaktionen für zugehörige Token-Konten filtern:

  * `none`: Nur Transaktionen zurückgeben, die die angegebene Adresse referenzieren (Standard)
  * `balanceChanged`: Transaktionen zurückgeben, die entweder die angegebene Adresse referenzieren oder das Guthaben eines Token-Kontos ändern, das der angegebenen Adresse gehört (empfohlen)
  * `all`: Transaktionen zurückgeben, die entweder die angegebene Adresse referenzieren oder ein beliebiges Token-Konto ändern, das der angegebenen Adresse gehört

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

<ParamField body="filters.tokenTransfer" type="object">
  Auf Transaktionen filtern, bei denen die abgefragte Adresse an einem Token-Transfer teilgenommen hat, der zu einem Kontrahenten passt, der Richtung, Prägung oder einem Rohmengenbereich entspricht. Alle Felder sind optional und werden mit UND-Semantik kombiniert.

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

<ParamField body="filters.tokenTransfer.with" type="string">
  Kontrahentenadresse. Passt zu Transfers, deren andere Seite diese Adresse ist.
</ParamField>

<ParamField body="filters.tokenTransfer.direction" type="string" default="any">
  Nach Transferrichtung relativ zur abgefragten Adresse filtern:

  * `in`: Transfers, die von der abgefragten Adresse empfangen wurden
  * `out`: Transfers, die von der abgefragten Adresse gesendet wurden
  * `any`: Ein- und ausgehende Transfers
</ParamField>

<ParamField body="filters.tokenTransfer.mint" type="string">
  Token-Prägung, nach der gefiltert werden soll.
</ParamField>

<ParamField body="filters.tokenTransfer.amount" type="object">
  Mengengegenüberstellung unter Verwendung der rohen On-Chain-Menge, nicht der UI- oder dezimalangepaßten Menge. Unterstützt `gt`, `gte`, `lt` und `lte`.
</ParamField>

<ParamField body="encoding" type="string">
  Kodierungsformat für Transaktionsdaten (gilt nur, wenn `transactionDetails: "full"`). Gleich wie `getTransaction` API. Optionen: `json`, `jsonParsed`, `base64`, `base58`
</ParamField>

<ParamField body="maxSupportedTransactionVersion" type="number">
  Maximal zurückzugebende Transaktionsversion festlegen. Wenn weggelassen, werden nur Legacy-Transaktionen zurückgegeben. Auf `1` setzen, um Legacy-, v0- und v1-Transaktionen einzuschließen.
</ParamField>

<ParamField body="minContextSlot" type="number">
  Der minimale Slot, bei dem die Anfrage ausgewertet werden kann
</ParamField>

### Messung

Erfolgreiche Antworten werden nach dem zurückgegebenen Inhalt gemessen:

| Antworttyp                    | Guthaben                                                                           |
| ----------------------------- | ---------------------------------------------------------------------------------- |
| Vollständige Transaktionen    | 10 Guthaben pro 100 zurückgegebene Transaktionen, aufgerundet; 10-Minimum Guthaben |
| Nur Signaturen                | 10 Guthaben pauschal, unabhängig von der Anzahl                                    |
| Fehlgeschlagene API-Antworten | Kostenlos                                                                          |

## Antwort

Die Antwortform ist abhängig von `transactionDetails`. Signaturen-Modus gibt leichte Signaturdatensätze zurück; Vollständiger Modus gibt vollständige Transaktionen und Metadatenobjekte zurück.

<Tabs>
  <Tab title="Signatur-Antwort">
    ```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="Vollständige Transaktionsantwort">
    ```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>

### Antwortfelder

| Feld                 | Typ            | Beschreibung                                                                                                                                                                                                                                                     |
| -------------------- | -------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `signature`          | string         | Transaktionssignatur (base-58 kodiert). Nur im Signaturmodus.                                                                                                                                                                                                    |
| `slot`               | number         | Der Slot, der den Block mit dieser Transaktion enthält.                                                                                                                                                                                                          |
| `transactionIndex`   | number         | Der nullbasierte Index der Transaktion innerhalb ihres Blocks. Nützlich für die Transaktionsordnung und Blockrekonstruktion.                                                                                                                                     |
| `blockTime`          | number \| null | Geschätzte Produktionszeit als Unix-Timestamp (Sekunden seit Epoche).                                                                                                                                                                                            |
| `err`                | object \| null | Fehler, falls die Transaktion fehlgeschlagen ist, ansonsten null. Nur im Signaturmodus.                                                                                                                                                                          |
| `memo`               | string \| null | Memo, das der Transaktion zugeordnet ist. Nur im Signaturmodus.                                                                                                                                                                                                  |
| `confirmationStatus` | string         | Clusterbestätigungsstatus der Transaktion. Nur im Signaturmodus.                                                                                                                                                                                                 |
| `transaction`        | object         | Vollständige Transaktionsdaten. Nur im vollständigen Modus.                                                                                                                                                                                                      |
| `meta`               | object         | Transaktionsstatus-Metadaten — gleiche Form wie `getTransaction`, einschließlich `err`, `fee`, `preBalances`/`postBalances`, `preTokenBalances`/`postTokenBalances`, `innerInstructions`, `logMessages`, und `computeUnitsConsumed`. Nur im vollständigen Modus. |
| `paginationToken`    | string \| null | Token zum Abrufen der nächsten Seite oder null, wenn keine weiteren Ergebnisse.                                                                                                                                                                                  |

Das Feld `transactionIndex` ist exklusiv für `getTransactionsForAddress`. Andere ähnliche Endpunkte wie `getSignaturesForAddress`, `getTransaction` und `getTransactions` enthalten dieses Feld nicht.

Im vollständigen Modus ist `meta` das vollständige Transaktionsmetadata-Objekt — identisch in der Form wie `getTransaction`. Es enthält `preTokenBalances` und `postTokenBalances`, sodass Sie Token-Guthabenänderungen (z. B. um Swaps zu erkennen) direkt aus der Antwort berechnen können, ohne weitere Aufrufe.

## Filter

Sie können Vergleichsoperatoren für `slot`, `blockTime` und `signature` verwenden, zusätzlich zu den speziellen `status`, `tokenAccounts` und `tokenTransfer` Filtern. Die Kombination mehrerer Filter grenzt das Ergebnis auf deren Schnittmenge ein.

### Vergleichsoperatoren

Diese Operatoren funktionieren wie Datenbankabfragen und geben Ihnen präzise Kontrolle über Ihren Datenbereich.

| Operator | Vollständiger Name  | Beschreibung                                               | Beispiel                        |
| -------- | ------------------- | ---------------------------------------------------------- | ------------------------------- |
| `gte`    | Größer oder gleich  | Werte einbeziehen, die ≥ angegebenem Wert sind             | `slot: { gte: 100 }`            |
| `gt`     | Größer als          | Werte einbeziehen, die > angegebenem Wert sind             | `blockTime: { gt: 1641081600 }` |
| `lte`    | Kleiner oder gleich | Werte einbeziehen, die ≤ angegebenem Wert sind             | `slot: { lte: 2000 }`           |
| `lt`     | Kleiner als         | Werte einbeziehen, die \< angegebenem Wert sind            | `blockTime: { lt: 1641168000 }` |
| `eq`     | Gleich              | Werte einbeziehen, die exakt gleich (nur `blockTime`) sind | `blockTime: { eq: 1641081600 }` |

### Enum-Filter

| Filter          | Beschreibung                                      | Werte                               |
| --------------- | ------------------------------------------------- | ----------------------------------- |
| `status`        | Transaktionen nach Erfolg/Misserfolg filtern      | `succeeded`, `failed` oder `any`    |
| `tokenAccounts` | Transaktionen für zugehörige Token-Konten filtern | `none`, `balanceChanged` oder `all` |

Beispiele für kombinierte Filter:

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

### Zugehörige Token-Konten

Auf Solana hält ein Wallet keine Token direkt. Stattdessen besitzt das Wallet Token-Konten, und diese Token-Konten halten die Tokens. Wenn Ihnen jemand USDC sendet, geht es an Ihr USDC-Token-Konto, nicht an Ihre Haupt-Wallet-Adresse.

Diese Methode ist einzigartig, da sie eine **vollständige Token-Historie** abfragen kann, einschließlich der zugehörigen Token-Konten (ATAs) eines Wallets. Native RPC-Methoden wie `getSignaturesForAddress` enthalten keine ATAs.

Der `tokenAccounts` Filter steuert dieses Verhalten:

* **`none`** (Standard): Gibt nur Transaktionen zurück, die die Wallet-Adresse direkt referenzieren. Verwenden Sie dies, wenn Sie sich nur für direkte Wallet-Interaktionen interessieren.
* **`balanceChanged`** (empfohlen): Gibt Transaktionen zurück, die entweder die Wallet-Adresse referenzieren oder das Guthaben eines Token-Kontos ändern, das dem Wallet gehört. Dies filtert Spam und nicht zusammenhängende Vorgänge wie Gebührensammlungen oder Delegationen aus und bietet Ihnen einen klaren Überblick über die sinnvolle Wallet-Aktivität.
* **`all`**: Gibt alle Transaktionen zurück, die die Wallet-Adresse oder ein beliebiges Token-Konto, das der Wallet gehört, referenzieren.

Der `tokenAccounts` Filter unterstützt keine Transaktionen vor Dezember 2022. Er ist abhängig von Metadaten der Token-Transfers, die in Solana auf Slot 111,491,819 eingeführt wurden. Um frühere Aktivitäten abzudecken, siehe das [historische Workaround für Token-Konten](#einschränkungen-und-randfälle).

### Token-Transfer-Filter

Der `tokenTransfer` Filter grenzt Ergebnisse auf Transaktionen ein, bei denen die abgefragte Adresse an einem Token-Transfer teilgenommen hat, der bestimmten Kriterien entspricht: einem bestimmten Kontrahenten, Prägung, Richtung oder einem Mengenumfang.

Verwenden Sie ihn, um Fragen wie:

* Wann hat diese Wallet USDC von einem bestimmten Kontrahenten erhalten?
* Zeige alle ausgehenden Transfers über 1.000 Token.
* Wann hat diese Wallet jemals diese bestimmte Prägung berührt?

Der Filter ist ein optionales Feld innerhalb des `filters` Objekts der Anfragekonfiguration:

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

Alle Felder innerhalb `tokenTransfer` sind optional. Die Kombination mehrerer Felder wird als UND behandelt.

| Feld        | Typ                          | Standard | Beschreibung                                                                                           |
| ----------- | ---------------------------- | -------- | ------------------------------------------------------------------------------------------------------ |
| `with`      | string (pubkey)              | -        | Kontrahentenadresse. Passt zu Transfers, deren andere Seite diese Adresse ist.                         |
| `direction` | `"in"` \| `"out"` \| `"any"` | `"any"`  | Ob die abgefragte Adresse empfangen, gesendet hat oder beides.                                         |
| `mint`      | string (pubkey)              | -        | Token-Prägung, nach der gefiltert werden soll.                                                         |
| `amount`    | object                       | -        | Mengengegenüberstellung. Verwendet die rohe On-Chain-Menge, nicht die UI- oder dezimalangepaßte Menge. |

Mengengrenzenoperatoren:

| Operator | Bedeutung           |
| -------- | ------------------- |
| `gt`     | Streng größer als   |
| `gte`    | Größer oder gleich  |
| `lt`     | Streng kleiner als  |
| `lte`    | Kleiner oder gleich |

Sie können Mengenoperatoren kombinieren, wie `{ "gte": 1000000, "lte": 5000000 }` für einen geschlossenen Bereich. `tokenTransfer` fügt sich mit den anderen obersten Filtern (`slot`, `blockTime`, `status`, und `tokenAccounts`); das Endergebnis ist der Schnittpunkt.

## Beispiele

### Zeitbasierte Analysen

Monatliche Transaktionsberichte generieren:

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

Vorgehensweise für Analysen:

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

### Token-Prägungserstellung

Finden Sie die Transaktion zur Prägungserstellung für ein bestimmtes Token:

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

Für die Erstellung eines Liquiditätspools, fragen Sie die Pool-Adresse ab:

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

Dies findet den genauen Moment, in dem eine Token-Prägung oder ein Liquiditätspool erstellt wurde, einschließlich der Erstelleradresse und der Anfangsparameter.

### Finanzierungstransaktionen

Finden Sie heraus, wer eine bestimmte Adresse finanziert hat:

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

Analysieren Sie dann die Transaktionsdaten, um SOL-Transfers zu finden:

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

Die ersten paar Transaktionen offenbaren oft die Finanzierungsquelle und können helfen, verwandte Adressen oder Finanzierungsmuster zu identifizieren.

### Token-Transfers

Mit `tokenTransfer` filtern, um spezifische Token-Bewegungen zu isolieren.

USDC-Zuflüsse zu einer Adresse:

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

Große ausgehende Transfers zu einem bestimmten Kontrahenten:

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

Kombiniert mit Slot-Bereich und Status:

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

## Paginierung

Wenn Sie mehr Transaktionen haben als Ihr Limit, verwenden Sie `paginationToken` aus der Antwort, um die nächste Seite abzurufen. Das Token ist ein einfacher String im Format `"slot:position"`, der der API mitteilt, wo sie fortfahren soll.

Verwenden Sie das Paginierungstoken aus jeder Antwort, um die nächste Seite abzurufen:

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

### Mehrere Adressen

Sie können nicht mehrere Adressen in einer einzigen Anfrage abfragen. Jede Adressabfrage zählt als separate API-Anfrage und wird entsprechend gemessen. Um Transaktionen für mehrere Adressen abzurufen, fragen Sie jede Adresse im gleichen Zeit- oder Slotfenster ab und fügen Sie sie dann zusammen und sortieren Sie sie:

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

Für größere Historienabfragen iterieren Sie durch Zeit- oder Slotfenster (z. B. 1000 Slots auf einmal) und wiederholen Sie dieses Muster.

## Beste Praktiken

**Leistung.** Verwenden Sie `transactionDetails: "signatures"`, wenn Sie keine vollständigen Transaktionsdaten benötigen. Verwenden Sie angemessene Seitengrößen für bessere Antwortzeiten und filtern Sie nach Zeitbereichen oder spezifischen Slots für gezieltere Abfragen.

**Filterung.** Beginnen Sie mit breiten Filtern und engen Sie sich schrittweise ein. Verwenden Sie zeitbasierte Filter für Analyse und Berichterstellungs-Workflows und kombinieren Sie mehrere Filter für präzise Abfragen, die auf bestimmte Transaktionstypen oder Zeiträume abzielen.

**Paginierung.** Speichern Sie Paginierungstokens, wenn Sie große Abfragen später wieder aufnehmen müssen. Überwachen Sie die Paginierungstiefe für die Leistungsplanung und verwenden Sie die aufsteigende Reihenfolge, wenn Sie historische Ereignisse chronologisch wiedergeben müssen.

**Fehlerbehandlung.** Behandeln Sie Rate Limits mit exponentiellem Backoff. Validieren Sie Adressen, bevor Sie Anfragen stellen, und cachen Sie Ergebnisse, wenn passend, um die API-Nutzung zu reduzieren.

## Einschränkungen und Randfälle

Ein kleiner Satz von Adressen wird zu Legacy-Archiv-Ressourcen geroutet, ist auf Slot-Scan-Fallback beschränkt oder gibt leere Ergebnisse zurück. Die Entdeckung von Token-Konten vor Slot 111,491,819 erfordert ebenfalls einen Workaround. Erweitern Sie die folgenden Abschnitte für die vollständigen Details.

<Accordion title="Nicht unterstützte und speziell geroutete Adressen">
  **Zu altem Archiv geroutet.** Anfragen für diese Adressen werden zu unserem alten Archivsystem geroutet.

  | Adresse                                       | Name                                                                                                        |
  | --------------------------------------------- | ----------------------------------------------------------------------------------------------------------- |
  | `Stake11111111111111111111111111111111111111` | [Stake-Programm](https://orbmarkets.io/address/Stake11111111111111111111111111111111111111/history)         |
  | `StakeConfig11111111111111111111111111111111` | [Stake-Konfiguration](https://orbmarkets.io/address/StakeConfig11111111111111111111111111111111/history)    |
  | `Sysvar1111111111111111111111111111111111111` | [Sysvar-Besitzer](https://orbmarkets.io/address/Sysvar1111111111111111111111111111111111111/history)        |
  | `AddressLookupTab1e1111111111111111111111111` | [Adress-Lookup-Tabelle](https://orbmarkets.io/address/AddressLookupTab1e1111111111111111111111111/history)  |
  | `BPFLoaderUpgradeab1e11111111111111111111111` | [BPF Loader Upgradeable](https://orbmarkets.io/address/BPFLoaderUpgradeab1e11111111111111111111111/history) |

  **Slot-Scan-Fallback.** Anfragen für diese Adressen werden zu unserem neuen Archivsystem weitergeleitet und sind durch einen Slot-Scan-Ansatz (maximal 100 Slots) abfragbar. Diese Daten sind jedoch nicht indexiert.

  | Adresse                                       | Name                                                                                                |
  | --------------------------------------------- | --------------------------------------------------------------------------------------------------- |
  | `11111111111111111111111111111111`            | [System-Programm](https://orbmarkets.io/address/11111111111111111111111111111111/history)           |
  | `ComputeBudget111111111111111111111111111111` | [Compute-Budget](https://orbmarkets.io/address/ComputeBudget111111111111111111111111111111/history) |
  | `MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr` | [Memo-Programm](https://orbmarkets.io/address/MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr/history)  |
  | `Vote111111111111111111111111111111111111111` | [Vote-Programm](https://orbmarkets.io/address/Vote111111111111111111111111111111111111111/history)  |

  **Gibt leer zurück (`is_reserved_address`).** Anfragen werden zu unserem neuen Archivsystem weitergeleitet, jedoch sind die Daten nicht indexiert und Abfragen geben leer zurück.

  | Adresse                                        | Name                                                                                                           |
  | ---------------------------------------------- | -------------------------------------------------------------------------------------------------------------- |
  | `BPFLoader1111111111111111111111111111111111`  | [BPF Loader (veraltet)](https://orbmarkets.io/address/BPFLoader1111111111111111111111111111111111/history)     |
  | `BPFLoader2111111111111111111111111111111111`  | [BPF Loader](https://orbmarkets.io/address/BPFLoader2111111111111111111111111111111111/history)                |
  | `Config1111111111111111111111111111111111111`  | [Config-Programm](https://orbmarkets.io/address/Config1111111111111111111111111111111111111/history)           |
  | `Ed25519SigVerify111111111111111111111111111`  | [Ed25519-Programm](https://orbmarkets.io/address/Ed25519SigVerify111111111111111111111111111/history)          |
  | `Feature111111111111111111111111111111111111`  | [Feature-Programm](https://orbmarkets.io/address/Feature111111111111111111111111111111111111/history)          |
  | `KeccakSecp256k11111111111111111111111111111`  | [Secp256k1-Programm](https://orbmarkets.io/address/KeccakSecp256k11111111111111111111111111111/history)        |
  | `LoaderV411111111111111111111111111111111111`  | [Loader V4](https://orbmarkets.io/address/LoaderV411111111111111111111111111111111111/history)                 |
  | `NativeLoader1111111111111111111111111111111`  | [Native Loader](https://orbmarkets.io/address/NativeLoader1111111111111111111111111111111/history)             |
  | `SysvarC1ock11111111111111111111111111111111`  | [Clock Sysvar](https://orbmarkets.io/address/SysvarC1ock11111111111111111111111111111111/history)              |
  | `SysvarEpochSchedu1e111111111111111111111111`  | [Epoch Schedule Sysvar](https://orbmarkets.io/address/SysvarEpochSchedu1e111111111111111111111111/history)     |
  | `SysvarFees111111111111111111111111111111111`  | [Fees Sysvar](https://orbmarkets.io/address/SysvarFees111111111111111111111111111111111/history)               |
  | `Sysvar1nstructions1111111111111111111111111`  | [Instructions Sysvar](https://orbmarkets.io/address/Sysvar1nstructions1111111111111111111111111/history)       |
  | `SysvarRecentB1ockHashes11111111111111111111`  | [Recent Blockhashes Sysvar](https://orbmarkets.io/address/SysvarRecentB1ockHashes11111111111111111111/history) |
  | `SysvarRent111111111111111111111111111111111`  | [Rent Sysvar](https://orbmarkets.io/address/SysvarRent111111111111111111111111111111111/history)               |
  | `SysvarRewards111111111111111111111111111111`  | [Rewards Sysvar](https://orbmarkets.io/address/SysvarRewards111111111111111111111111111111/history)            |
  | `SysvarS1otHashes111111111111111111111111111`  | [Slot Hashes Sysvar](https://orbmarkets.io/address/SysvarS1otHashes111111111111111111111111111/history)        |
  | `SysvarS1otHistory11111111111111111111111111`  | [Slot History Sysvar](https://orbmarkets.io/address/SysvarS1otHistory11111111111111111111111111/history)       |
  | `SysvarStakeHistory1111111111111111111111111`  | [Stake History Sysvar](https://orbmarkets.io/address/SysvarStakeHistory1111111111111111111111111/history)      |
  | `SysvarEpochRewards11111111111111111111111111` | [Epoch Rewards Sysvar](https://orbmarkets.io/address/SysvarEpochRewards11111111111111111111111111/history)     |
  | `SysvarLastRestartS1ot1111111111111111111111`  | [Last Restart Slot Sysvar](https://orbmarkets.io/address/SysvarLastRestartS1ot1111111111111111111111/history)  |
</Accordion>

<Accordion title="Workaround: historische Token-Konto-Entdeckung (vor Slot 111,491,819)">
  Für Adressen mit Token-Kontoaktivität vor Slot 111,491,819 kann der `tokenAccounts` Filter die Zugehörigkeit nicht bestimmen, da das Feld `owner` in Token-Guthabenmetadaten damals nicht existierte. Um vollständige Ergebnisse zu erhalten, können Sie diese Token-Konten manuell entdecken, indem Sie frühe Transaktionsanweisungen analysieren und dann `getTransactionsForAddress` parallel für jedes Konto abfragen.

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

## Wie unterscheidet sich dies zu getSignaturesForAddress?

Wenn Sie mit der standardmäßigen `getSignaturesForAddress` Methode vertraut sind, fasst `getTransactionsForAddress` mehrstufige Abläufe in einem einzigen Aufruf zusammen und fügt Filterung, Sortierung und Unterstützung für Token-Konten hinzu. Für eine schrittweise Umstellung des bestehenden Codes siehe den [Migrationsleitfaden](/docs/de/rpc/migrate-to-gettransactionsforaddress).

### Vollständige Transaktionen in einem Aufruf erhalten

Mit `getSignaturesForAddress` benötigen Sie zwei Schritte:

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

Mit `getTransactionsForAddress` ist es ein Aufruf:

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

### Token-Historie in einem Aufruf erhalten

Mit `getSignaturesForAddress` müssen Sie zuerst `getTokenAccountsByOwner` aufrufen und dann für jedes Token-Konto abfragen:

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

Mit `getTransactionsForAddress` müssen Sie nur `filters.tokenAccounts` setzen:

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

### Zusätzliche Funktionen

<CardGroup cols={2}>
  <Card title="Chronologische Sortierung" icon="arrow-up">
    Sortieren Sie Transaktionen von ältesten zu neuesten mit `sortOrder: 'asc'`.
  </Card>

  <Card title="Zeitbasierte Filterung" icon="clock">
    Nach Zeitbereichen mit `blockTime` Filtern.
  </Card>

  <Card title="Statusfilterung" icon="filter">
    Holen Sie sich nur erfolgreiche oder fehlgeschlagene Transaktionen mit dem `status` Filter.
  </Card>

  <Card title="Einfachere Paginierung" icon="list">
    Verwenden Sie `paginationToken` anstelle der verwirrenden `before`/`until` Signaturen.
  </Card>
</CardGroup>

## Weitere Schritte

<CardGroup cols={2}>
  <Card title="Indexierungsleitfaden" icon="layer-group" href="/docs/de/rpc/how-to-index-solana-data">
    Verwenden Sie getTransactionsForAddress zum Auffüllen und Synchronisieren eines Solana-Index.
  </Card>

  <Card title="getTransfersByAddress" icon="arrow-right-arrow-left" href="/docs/de/rpc/gettransfersbyaddress">
    Analysierte, nur auf Übertragungen basierende Historie für Zahlungen und Abgleich.
  </Card>

  <Card title="API-Referenz" icon="code" href="/docs/de/api-reference/rpc/http/gettransactionsforaddress">
    Vollständiges Anfrage- und Antwortschema für getTransactionsForAddress.
  </Card>

  <Card title="Übersicht über historische Daten" icon="clock-rotate-left" href="/docs/de/rpc/historical-data">
    Vergleichen Sie alle Solana-Historische Datenmethoden.
  </Card>
</CardGroup>