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

# Transaction History

> Abrufbare, lesbare Transaktionshistorie für jede Solana-Adresse mit Filterung, Zeit- und Slotbereichen sowie Paginierung.

<Warning>
  Die Enhanced Transactions API ist ein Legacy-Produkt im Wartungsmodus. Sie funktioniert weiterhin und diese Seiten bleiben verfügbar, aber es werden keine neuen Parser-Typen oder Funktionen hinzugefügt. Ihr Nachfolger ist [Parsed Events](/docs/de/parsed-events), der Anweisungen über den IDL-Katalog decodiert und sich in der offenen Beta auf kostenpflichtigen Plänen befindet – der [Migrationsleitfaden](/docs/de/parsed-events/guides/migrate-from-enhanced-transactions) erklärt den Umstieg Schritt für Schritt. Sie können auch [`getTransactionsForAddress`](/docs/de/rpc/gettransactionsforaddress) für Transaktionshistorie und Backfill sowie die [Wallet API](/docs/de/wallet-api/overview) für lesbare Wallet-Daten nutzen.
</Warning>

## Übersicht

Der Transaction History-Endpunkt liefert eine lesbare Transaktionshistorie für jede Solana-Adresse. Statt rohen Anweisungsdaten und Kontenlisten erhalten Sie strukturierte Informationen über:

* Was in der Transaktion passiert ist (Transfers, Swaps, NFT-Aktivitäten).
* Welche Konten beteiligt waren.
* Wie viel SOL oder wie viele Tokens transferiert wurden.
* Zugehörige Metadaten (Token-Mint-Adressen, Token-Namen, Token-Symbole und mehr).

Senden Sie eine `GET`-Anfrage an `/v0/addresses/{address}/transactions`. Im Hintergrund wird dieser Endpunkt von der [`getTransactionsForAddress`](/docs/de/rpc/gettransactionsforaddress) RPC-Methode betrieben.

## Wann verwenden

* Sie zeigen einem Benutzer die Transaktionshistorie einer Adresse an (Wallets, Portfoliotracking, Explorer).
* Sie möchten eine vorgeparste, lesbare Historie ohne eigenen Decoder.
* Sie müssen die Historie nach Transaktionstyp, Zeit- oder Slotbereich filtern.
* Sie benötigen die vollständige Token-Historie einer Wallet, einschließlich zugehöriger Token-Konten (ATAs) — siehe unten.

Für neue Builds ist [`getTransactionsForAddress`](/docs/de/rpc/gettransactionsforaddress) der moderne, Helius-native Weg mit serverseitigen Filtern und Token-Konten-Abfragen.

## Schnellstart

<Steps>
  <Step title="Holen Sie sich Ihren API-Schlüssel">
    Melden Sie sich bei [dashboard.helius.dev](https://dashboard.helius.dev) an und kopieren Sie Ihren API-Schlüssel.
  </Step>

  <Step title="Abfrage des Transaktionsendpunkts der Adresse">
    Abrufen der Transaktionshistorie für eine beliebige Solana-Adresse.

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

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

        fetchWalletTransactions();
        ```
      </Tab>

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

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

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

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

  <Step title="Filtern und paginieren">
    Verengen Sie die Ergebnisse mit den unten stehenden `type`, Zeit- und Slotfiltern, dann durchlaufen Sie Adressen mit hohem Volumen mithilfe von Signatur-Cursorn.
  </Step>
</Steps>

## Netzwerkunterstützung

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

## Anforderungsparameter

| Parameter          | Beschreibung                                                                    | Standard    | Beispiel                         |
| ------------------ | ------------------------------------------------------------------------------- | ----------- | -------------------------------- |
| `limit`            | Anzahl der zurückzugebenden Transaktionen (1-100)                               | 10          | `&limit=25`                      |
| `before-signature` | Abrufen von Transaktionen vor dieser Signatur (verwenden mit `sort-order=desc`) | -           | `&before-signature=sig123...`    |
| `after-signature`  | Abrufen von Transaktionen nach dieser Signatur (verwenden mit `sort-order=asc`) | -           | `&after-signature=sig456...`     |
| `type`             | Filtern nach Transaktionstyp                                                    | -           | `&type=NFT_SALE`                 |
| `sort-order`       | Sortierreihenfolge der Ergebnisse                                               | `desc`      | `&sort-order=asc`                |
| `token-accounts`   | Filtern von Transaktionen für zugehörige Token-Konten                           | `none`      | `&token-accounts=balanceChanged` |
| `commitment`       | Verpflichtungsstufe                                                             | `finalized` | `&commitment=confirmed`          |

### Zeitbasierte Filterung

| Parameter  | Beschreibung                                       | Beispiel               |
| ---------- | -------------------------------------------------- | ---------------------- |
| `gt-time`  | Transaktionen nach diesem Unix-Zeitstempel         | `&gt-time=1656442333`  |
| `gte-time` | Transaktionen zu oder nach diesem Unix-Zeitstempel | `&gte-time=1656442333` |
| `lt-time`  | Transaktionen vor diesem Unix-Zeitstempel          | `&lt-time=1656442333`  |
| `lte-time` | Transaktionen zu oder vor diesem Unix-Zeitstempel  | `&lte-time=1656442333` |

### Slot-basierte Filterung

| Parameter  | Beschreibung                           | Beispiel              |
| ---------- | -------------------------------------- | --------------------- |
| `gt-slot`  | Transaktionen nach diesem Slot         | `&gt-slot=148277128`  |
| `gte-slot` | Transaktionen zu oder nach diesem Slot | `&gte-slot=148277128` |
| `lt-slot`  | Transaktionen vor diesem Slot          | `&lt-slot=148277128`  |
| `lte-slot` | Transaktionen zu oder vor diesem Slot  | `&lte-slot=148277128` |

Anmerkungen zur Filterung:

* Zeitparameter verwenden Unix-Zeitstempel (Sekunden seit Epoch); Slot-Parameter verwenden Solana-Slot-Nummern.
* Sie können Zeit- und Slot-basierte Filter nicht in derselben Anfrage kombinieren.
* Verwenden Sie `sort-order=asc` für aufsteigend (älteste zuerst) oder `sort-order=desc` für absteigend (neueste zuerst).
* Verwenden Sie Zeit- oder Slot-Filter, um den Suchraum zu reduzieren, wenn Sie den ungefähren Zeitraum kennen, und kombinieren Sie sie mit `limit`, um die Seitengröße zu steuern.

## Zugehörige Token-Konten

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

Dieser Endpunkt ist einzigartig, da er eine Wallets **vollständige Token-Historie** einschließlich der zugehörigen Token-Konten (ATAs) abfragen kann. Native RPC-Methoden wie `getSignaturesForAddress` schließen ATAs nicht ein.

Der `token-accounts`-Filter steuert dieses Verhalten:

* **`none`** (Standard) — gibt nur Transaktionen zurück, die direkt auf die Wallet-Adresse verweisen. Verwenden Sie dies, wenn Sie sich nur für direkte Wallet-Interaktionen interessieren.
* **`balanceChanged`** (empfohlen) — gibt Transaktionen zurück, die die Wallet-Adresse referenzieren oder den Saldo eines von der Wallet gehaltenen Token-Kontos ändern. Dies filtert Spam und nicht zusammenhängende Operationen wie Gebühreneinziehungen oder Delegationen heraus und bietet Ihnen einen sauberen Überblick über die wesentliche Wallet-Aktivität.
* **`all`** — gibt alle Transaktionen zurück, die die Wallet-Adresse oder ein von der Wallet gehaltenes Token-Konto referenzieren.

<Warning>
  Der `token-accounts`-Filter baut auf dem `owner`-Feld in den Token-Saldo-Metadaten auf, das vor Slot 111,491,819 (\~Dezember 2022) nicht verfügbar war. Transaktionen, die vor diesem Slot mit Token-Konten aktiv waren, können in den `balanceChanged`- und `all`-Ergebnissen fehlen. Sehen Sie sich das [getTransactionsForAddress-Tutorial](/docs/de/rpc/gettransactionsforaddress#einschränkungen-und-randfälle) für einen Workaround mit einem vollständigen Code-Beispiel an.
</Warning>

## Filter

### Nach Transaktionstyp filtern

Erhalten Sie nur bestimmte Transaktionstypen, wie NFT-Verkäufe, Token-Transfers oder Swaps:

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

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

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

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

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

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

Für die vollständige Liste der unterstützten Transaktionstypen sehen Sie sich die [Transaction History API-Referenz](/docs/de/api-reference/enhanced-transactions/gettransactionsbyaddress) an.

### Filterung zur Laufzeit

<Note>
  Die Typfilterung erfolgt zur Laufzeit: Die API durchsucht Transaktionen nacheinander, bis sie mindestens 50 passende Elemente findet. Wenn innerhalb des Suchfensters keine Übereinstimmungen gefunden werden können, wird ein Fehler mit einer Signatur zurückgegeben, um die Suche fortzusetzen. Dies ist erwartetes Verhalten, kein Fehler.
</Note>

Wenn innerhalb des aktuellen Suchfensters keine übereinstimmenden Transaktionen gefunden werden, gibt die API eine Fehlermeldung wie diese zurück:

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

Um fortzufahren, verwenden Sie die Signatur aus der Fehlermeldung mit dem entsprechenden Parameter (`before-signature` für absteigend, `after-signature` für aufsteigend) bei Ihrer nächsten Anfrage.

<Accordion title="Fortsetzungsschleife für Typfilter (vollständiges Beispiel)">
  ```javascript theme={"system"}
  const fetchFilteredTransactions = async (sortOrder = 'desc') => {
    const walletAddress = "M2mx93ekt1fmXSVkTrUL9xVFHkmME8HTUi5Cyc5aF7K";
    const transactionType = "NFT_SALE";
    let continuationSignature = null;
    let allFilteredTransactions = [];
    let maxRetries = 10; // Prevent infinite loops
    let retryCount = 0;

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

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

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

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

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

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

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

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

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

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

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

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

  Wichtige Punkte:

  * Die API durchsucht bei der Verwendung von Typfiltern bis zu 50 Transaktionen auf einmal.
  * Wenn keine Übereinstimmungen gefunden werden, verwenden Sie die Signatur aus der Fehlermeldung, um die Suche fortzusetzen.
  * Verwenden Sie `before-signature` bei der Suche in absteigender Reihenfolge (Standard, neueste zuerst).
  * Verwenden Sie `after-signature` bei der Suche in aufsteigender Reihenfolge (älteste zuerst) — erforderlich für chronologische Suchen.
  * Implementieren Sie ein maximales Wiederholungs-Limit, um Endlosschleifen zu vermeiden.
</Accordion>

## Beispiele

Die folgenden Szenarien umfassen Zeit- und Slotbereiche, Sortierreihenfolge, ATAs und kombinierte Filter.

<Accordion title="Nach Zeitbereich filtern">
  Erhalten Sie Transaktionen innerhalb eines bestimmten Zeitfensters:

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

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

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

    <Tab title="Bestimmter Datumsbereich">
      ```javascript theme={"system"}
      const fetchTransactionsByDateRange = async () => {
        const walletAddress = "M2mx93ekt1fmXSVkTrUL9xVFHkmME8HTUi5Cyc5aF7K";

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

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

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

<Accordion title="Nach Slotbereich filtern">
  Erhalten Sie Transaktionen innerhalb eines bestimmten Slotbereichs:

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

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

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

<Accordion title="Sortierreihenfolge ändern">
  Erhalten Sie Transaktionen in aufsteigender Reihenfolge (älteste zuerst):

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

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

<Accordion title="Transfers für verwandte Token-Konten einbeziehen">
  Abfrage der vollständigen Historie einer Wallet, einschließlich zugehöriger Token-Adressen (ATAs):

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

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

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

<Accordion title="Mehrere Filter kombinieren">
  Kombinieren Sie Typfilterung mit einem Zeitbereich und benutzerdefinierter Sortierreihenfolge:

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

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

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

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

## Paginierung

Bei Adressen mit hohem Volumen blättern Sie durch die Ergebnisse, indem Sie die letzte Signatur in jedem Batch als Cursor verwenden:

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

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

    const response = await fetch(url);

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

    const transactions = await response.json();

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

  return allTransactions;
};
```

Um innerhalb eines Zeitbereichs zu paginieren, behalten Sie die Zeitfilter bei jeder Anfrage bei und geben Sie den `before-signature`-Cursor in jeder Schleife weiter:

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

  let beforeSignature = null;
  let allTransactions = [];

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

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

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

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

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

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

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

## Nächste Schritte

<CardGroup cols={2}>
  <Card title="getTransactionsForAddress" icon="clock-rotate-left" href="/docs/de/rpc/gettransactionsforaddress">
    Der moderne, Helius-native Ersatz für Transaktionshistorie und Backfill.
  </Card>

  <Card title="Wallet API" icon="wallet" href="/docs/de/wallet-api/overview">
    REST-Endpunkte für lesbare Wallet-Daten: Salden, Historie und Überweisungen.
  </Card>

  <Card title="Transaktionen parsen" icon="code" href="/docs/de/enhanced-transactions/parse-transactions">
    Parsen Sie eine oder mehrere Transaktionssignaturen in lesbare Daten.
  </Card>

  <Card title="Datenübersicht abrufen" icon="database" href="/docs/de/getting-data">
    Vergleichen Sie jede Helius-Option zur Abfrage von Solana-Daten.
  </Card>
</CardGroup>