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

# So rufen Sie die Transaktionshistorie eines Solana-Wallets ab

> Erhalten Sie die vollständige Transaktionshistorie für jedes Solana-Wallet mit Saldoänderungen für jede Transaktion — entwickelt für Portfolio-Tracker, Buchhaltung und Analysen.

<Note>
  Die Wallet-API befindet sich im Beta-Stadium. Endpunkte und Antwortformate können sich ändern.
</Note>

## Überblick

Der Transaktionshistorie-Endpunkt ruft die vollständige Transaktionshistorie für ein Solana-Wallet unter Verwendung der Enhanced Transactions API ab. Er gibt menschenlesbare, geparste Transaktionen mit Saldoänderungen für jede Transaktion in umgekehrt chronologischer Reihenfolge (neueste zuerst) zurück.

Der Endpunkt gibt bis zu 100 Transaktionen pro Anfrage zurück, daher ist die Paginierung manuell. Verwenden Sie den Parameter `before` mit `pagination.nextCursor`, um die nächste Seite abzurufen, und lesen Sie `pagination.hasMore`, um zu erfahren, wann mehr Ergebnisse verfügbar sind. Jede Anfrage ist ein einzelner API-Aufruf und kostet 100 Credits.

Der Parameter `tokenAccounts` steuert, ob Transaktionen, die Token-Konten betreffen, die dem Wallet gehören, einbezogen werden:

* `balanceChanged` (empfohlen): Enthält Transaktionen, die Token-Kontosaldi geändert haben, und filtert Spam.

<Warning>
  Der Filter `tokenAccounts` stützt sich auf das Feld `owner` in den Token-Saldo-Metadaten, das vor Slot 111.491.819 (\~Dezember 2022) nicht verfügbar war. Transaktionen mit aktiven Token-Konten vor diesem Slot könnten fehlen. Siehe das [getTransactionsForAddress-Tutorial](/docs/de/rpc/gettransactionsforaddress#einschränkungen-und-randfälle) für einen Workaround.
</Warning>

## Wann man dies verwendet

Verwenden Sie die Transaction History API, wenn Sie Folgendes benötigen:

* **Anzeigen eines Transaktions-Feeds**: Zeigen Sie Benutzern ihre vollständige Transaktionshistorie an.

## Schnellstart

### Grundlegende Abfrage der Historie

Holen Sie sich die neuesten Transaktionen mit Saldoänderungen:

<Tabs>
  <Tab title="JavaScript">
    ```javascript theme={"system"}
    const getTransactionHistory = async (address) => {
      const url = `https://api.helius.xyz/v1/wallet/${address}/history?api-key=YOUR_API_KEY`;

      const response = await fetch(url);
      if (!response.ok) {
        throw new Error(`HTTP error! status: ${response.status}`);
      }

      const data = await response.json();

      console.log(`Found ${data.data.length} transactions`);

      // Display recent transactions
      data.data.forEach(tx => {
        const date = new Date(tx.timestamp * 1000).toLocaleString();
        const status = tx.error ? 'Failed' : 'Success';

        console.log(`\n${status} - ${date}`);
        console.log(`Signature: ${tx.signature.slice(0, 20)}...`);
        console.log(`Fee: ${tx.fee} SOL`);

        // Show balance changes
        tx.balanceChanges.forEach(change => {
          const sign = change.amount > 0 ? '+' : '';
          console.log(`  ${sign}${change.amount} ${change.mint === 'SOL' ? 'SOL' : change.mint.slice(0, 8)}...`);
        });
      });

      return data;
    };

    getTransactionHistory("86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY");
    ```
  </Tab>

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

    def get_transaction_history(address: str):
        url = f"https://api.helius.xyz/v1/wallet/{address}/history"
        headers = {"X-Api-Key": "YOUR_API_KEY"}

        response = requests.get(url, headers=headers)
        response.raise_for_status()

        data = response.json()

        print(f"Found {len(data['data'])} transactions")

        # Display recent transactions
        for tx in data['data']:
            date = datetime.fromtimestamp(tx['timestamp']).strftime('%Y-%m-%d %H:%M:%S')
            status = 'Failed' if tx.get('error') else 'Success'

            print(f"\n{status} - {date}")
            print(f"Signature: {tx['signature'][:20]}...")
            print(f"Fee: {tx['fee']} SOL")

            # Show balance changes
            for change in tx['balanceChanges']:
                sign = '+' if change['amount'] > 0 else ''
                mint_display = 'SOL' if change['mint'] == 'SOL' else change['mint'][:8] + '...'
                print(f"  {sign}{change['amount']} {mint_display}")

        return data

    get_transaction_history("86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY")
    ```
  </Tab>

  <Tab title="cURL">
    ```bash theme={"system"}
    curl "https://api.helius.xyz/v1/wallet/86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY/history?api-key=YOUR_API_KEY"
    ```
  </Tab>
</Tabs>

### Paginierung für vollständige Historie

Holen Sie alle Transaktionen mit Paginierung unter Verwendung des Parameters `before` ab:

<Tabs>
  <Tab title="JavaScript">
    ```javascript theme={"system"}
    const getAllTransactionHistory = async (address) => {
      let allTransactions = [];
      let before = null;

      do {
        const url = before
          ? `https://api.helius.xyz/v1/wallet/${address}/history?api-key=YOUR_API_KEY&before=${before}`
          : `https://api.helius.xyz/v1/wallet/${address}/history?api-key=YOUR_API_KEY`;

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

        allTransactions = allTransactions.concat(data.data);
        before = data.pagination.hasMore ? data.pagination.nextCursor : null;

        console.log(`Fetched ${allTransactions.length} transactions so far...`);

      } while (before);

      console.log(`\nTotal transactions: ${allTransactions.length}`);
      return allTransactions;
    };

    getAllTransactionHistory("86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY");
    ```
  </Tab>

  <Tab title="Python">
    ```python theme={"system"}
    def get_all_transaction_history(address: str):
        all_transactions = []
        before = None

        while True:
            url = f"https://api.helius.xyz/v1/wallet/{address}/history"
            params = {"api-key": "YOUR_API_KEY"}

            if before:
                params["before"] = before

            response = requests.get(url, params=params, headers={"X-Api-Key": "YOUR_API_KEY"})
            response.raise_for_status()

            data = response.json()
            all_transactions.extend(data['data'])

            print(f"Fetched {len(all_transactions)} transactions so far...")

            if not data['pagination']['hasMore']:
                break

            before = data['pagination']['nextCursor']

        print(f"\nTotal transactions: {len(all_transactions)}")
        return all_transactions

    get_all_transaction_history("86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY")
    ```
  </Tab>
</Tabs>

## Abfrageparameter

| Parameter       | Typ     | Standard       | Beschreibung                                                                                              |
| --------------- | ------- | -------------- | --------------------------------------------------------------------------------------------------------- |
| `limit`         | integer | 100            | Maximale Anzahl an Transaktionen pro Anfrage (1-100)                                                      |
| `before`        | string  | -              | Hole Transaktionen vor dieser Signatur (verwenden Sie `pagination.nextCursor` aus der vorherigen Antwort) |
| `after`         | string  | -              | Hole Transaktionen nach dieser Signatur (für aufsteigende Paginierung)                                    |
| `type`          | string  | -              | Nach Transaktionstyp filtern (z. B. SWAP, TRANSFER, NFT\_SALE, TOKEN\_MINT)                               |
| `tokenAccounts` | string  | balanceChanged | Filter für Transaktionen mit Token-Konten: `none`, `balanceChanged` (empfohlen) oder `all`                |

### Verfügbare Transaktionstypen

Der Parameter `type` unterstützt die Filterung nach diesen Transaktionstypen:

`SWAP`, `TRANSFER`, `NFT_SALE`, `NFT_BID`, `NFT_LISTING`, `NFT_MINT`, `NFT_CANCEL_LISTING`, `TOKEN_MINT`, `BURN`, `COMPRESSED_NFT_MINT`, `COMPRESSED_NFT_TRANSFER`, `COMPRESSED_NFT_BURN`, `CREATE_STORE`, `WHITELIST_CREATOR`, `ADD_TO_WHITELIST`, `REMOVE_FROM_WHITELIST`, `AUCTION_MANAGER_CLAIM_BID`, `EMPTY_PAYMENT_ACCOUNT`, `UPDATE_PRIMARY_SALE_METADATA`, `ADD_TOKEN_TO_VAULT`, `ACTIVATE_VAULT`, `INIT_VAULT`, `INIT_BANK`, `INIT_STAKE`, `MERGE_STAKE`, `SPLIT_STAKE`, `CREATE_AUCTION_MANAGER`, `START_AUCTION`, `CREATE_AUCTION_MANAGER_V2`, `UPDATE_EXTERNAL_PRICE_ACCOUNT`, `EXECUTE_TRANSACTION`

### Filterbeispiele

<Tabs>
  <Tab title="Nach Typ filtern">
    ```javascript theme={"system"}
    // Get only SWAP transactions
    const url = `https://api.helius.xyz/v1/wallet/${address}/history?api-key=YOUR_API_KEY&type=SWAP`;
    ```
  </Tab>

  <Tab title="Token-Konten-Filter">
    ```javascript theme={"system"}
    // Exclude spam by only including transactions that changed token balances
    const url = `https://api.helius.xyz/v1/wallet/${address}/history?api-key=YOUR_API_KEY&tokenAccounts=balanceChanged`;

    // Only show direct wallet interactions
    const url = `https://api.helius.xyz/v1/wallet/${address}/history?api-key=YOUR_API_KEY&tokenAccounts=none`;
    ```
  </Tab>

  <Tab title="Kombinierte Filter">
    ```javascript theme={"system"}
    // Get only NFT sales that changed balances
    const url = `https://api.helius.xyz/v1/wallet/${address}/history?api-key=YOUR_API_KEY&type=NFT_SALE&tokenAccounts=balanceChanged`;
    ```
  </Tab>
</Tabs>

## Antwortformat

```json theme={"system"}
{
  "data": [
    {
      "signature": "5wHu1qwD7Jsj3xqWjdSEJmYr3Q5f5RjXqjqQJ7jqEj7jqEj7jqEj7jqEj7jqEj7jqE",
      "timestamp": 1704067200,
      "slot": 250000000,
      "fee": 0.000005,
      "feePayer": "86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY",
      "error": null,
      "balanceChanges": [
        {
          "mint": "So11111111111111111111111111111111111111111",
          "amount": -0.05,
          "decimals": 9
        },
        {
          "mint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
          "amount": 50.0,
          "decimals": 6
        }
      ]
    }
  ],
  "pagination": {
    "hasMore": true,
    "nextCursor": "5wHu1qwD7Jsj3xqWjdSEJmYr3Q5f5RjXqjqQJ7jqEj7jqEj7jqEj7jqEj7jqEj7jqE"
  }
}
```

### Felderklärungen

* **`timestamp`**: Unix-Sekunden. Kann `null` sein für sehr neue Transaktionen, die noch nicht vollständig verarbeitet wurden.

#### Beispielhafte Saldoänderungen

```javascript theme={"system"}
// Swap: Sold 0.05 SOL, received 5 USDC
{
  "balanceChanges": [
    { "mint": "SOL", "amount": -0.05, "decimals": 9 },
    { "mint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", "amount": 5.0, "decimals": 6 }
  ]
}

// Simple transfer: Sent 10 USDC
{
  "balanceChanges": [
    { "mint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", "amount": -10.0, "decimals": 6 }
  ]
}
```

## Anwendungsfälle

### Gesamtes Handelsvolumen berechnen

Alle Überweisungen summieren, um das Handelsvolumen zu erhalten:

```javascript theme={"system"}
const calculateTradingVolume = async (address, tokenMint) => {
  const transactions = await getAllTransactionHistory(address);

  let totalVolume = 0;

  transactions.forEach(tx => {
    tx.balanceChanges.forEach(change => {
      if (change.mint === tokenMint) {
        totalVolume += Math.abs(change.amount);
      }
    });
  });

  console.log(`Total ${tokenMint} volume: ${totalVolume}`);
  return totalVolume;
};

// Example: Calculate total USDC volume
calculateTradingVolume(
  "86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY",
  "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v" // USDC
);
```

### Steuerbericht erstellen

Erstellen Sie einen Transaktionsbericht für die Steuererklärung:

```javascript theme={"system"}
const generateTaxReport = async (address, year) => {
  const transactions = await getAllTransactionHistory(address);

  const startDate = new Date(`${year}-01-01`).getTime() / 1000;
  // Set to end of December 31st (23:59:59.999) to include all transactions from that day
  const endDate = new Date(`${year}-12-31T23:59:59.999Z`).getTime() / 1000;

  const taxableTransactions = transactions
    .filter(tx => tx.timestamp >= startDate && tx.timestamp <= endDate)
    .map(tx => ({
      date: new Date(tx.timestamp * 1000).toISOString(),
      signature: tx.signature,
      fee: tx.fee,
      balanceChanges: tx.balanceChanges,
      explorerUrl: `https://orbmarkets.io/tx/${tx.signature}`
    }));

  console.log(`Found ${taxableTransactions.length} transactions in ${year}`);

  // Export as JSON
  const report = {
    address,
    year,
    transactionCount: taxableTransactions.length,
    transactions: taxableTransactions
  };

  console.log(JSON.stringify(report, null, 2));
  return report;
};

generateTaxReport("86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY", 2024);
```

### Fehlgeschlagene Transaktionen verfolgen

Alle fehlgeschlagenen Transaktionen finden, um Fehler zu verstehen:

```javascript theme={"system"}
const getFailedTransactions = async (address) => {
  const data = await getTransactionHistory(address);

  const failed = data.data.filter(tx => tx.error !== null);

  console.log(`Found ${failed.length} failed transactions`);

  failed.forEach(tx => {
    const date = new Date(tx.timestamp * 1000).toLocaleString();
    console.log(`\n${date}`);
    console.log(`Signature: ${tx.signature}`);
    console.log(`Error: ${tx.error}`);
    console.log(`Fee Paid: ${tx.fee} SOL`);
  });

  return failed;
};
```

### Historischen Saldo rekonstruieren

Berechnen, wie der Saldo zu einem bestimmten Zeitpunkt war:

```javascript theme={"system"}
const getHistoricalBalance = async (address, targetTimestamp) => {
  const transactions = await getAllTransactionHistory(address);

  // Filter to transactions before target date
  const relevantTxs = transactions.filter(tx => tx.timestamp <= targetTimestamp);

  // Sum all balance changes
  const balances = {};

  relevantTxs.forEach(tx => {
    tx.balanceChanges.forEach(change => {
      if (!balances[change.mint]) {
        balances[change.mint] = 0;
      }
      balances[change.mint] += change.amount;
    });
  });

  console.log(`Historical balances as of ${new Date(targetTimestamp * 1000).toLocaleString()}:`);
  Object.entries(balances).forEach(([mint, balance]) => {
    console.log(`${mint}: ${balance}`);
  });

  return balances;
};

// Example: Get balances on Jan 1, 2024
getHistoricalBalance(
  "86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY",
  new Date("2024-01-01").getTime() / 1000
);
```

Für den genauen Saldo eines einzelnen Tokens zu einem bestimmten Zeitpunkt liest der [Historical Balance](/docs/de/wallet-api/balance-at) Endpunkt ihn direkt aus den On-Chain-Post-Saldi anstelle von clientseitigen Summenänderungen.

### Transaktionsgebühren analysieren

Gesamte gezahlte Gebühren berechnen:

```javascript theme={"system"}
const analyzeFees = async (address) => {
  const transactions = await getAllTransactionHistory(address);

  const totalFees = transactions.reduce((sum, tx) => sum + tx.fee, 0);
  const avgFee = totalFees / transactions.length;

  const successfulTxs = transactions.filter(tx => !tx.error);
  const failedTxs = transactions.filter(tx => tx.error);

  const wastedFees = failedTxs.reduce((sum, tx) => sum + tx.fee, 0);

  console.log(`Total Transactions: ${transactions.length}`);
  console.log(`Successful: ${successfulTxs.length}`);
  console.log(`Failed: ${failedTxs.length}`);
  console.log(`Total Fees Paid: ${totalFees.toFixed(6)} SOL`);
  console.log(`Average Fee: ${avgFee.toFixed(6)} SOL`);
  console.log(`Wasted on Failed Txs: ${wastedFees.toFixed(6)} SOL`);

  return {
    totalFees,
    avgFee,
    wastedFees,
    successRate: (successfulTxs.length / transactions.length) * 100
  };
};
```

## Beste Praktiken

* **Verwenden Sie Paginierung für die vollständige Historie.** Einige Wallets haben Hunderttausende von Transaktionen; paginieren Sie immer, wenn Sie alle abrufen.

## Häufige Fehler

| Fehlercode | Beschreibung                            | Lösung                                                                |
| ---------- | --------------------------------------- | --------------------------------------------------------------------- |
| 400        | Ungültiges Wallet-Adressformat          | Überprüfen Sie, ob die Adresse eine gültige Base58-Solana-Adresse ist |
| 401        | Fehlender oder ungültiger API-Schlüssel | Überprüfen Sie, ob Ihr API-Schlüssel in der Anfrage enthalten ist     |
| 429        | Rate-Limit überschritten                | Reduzieren Sie die Anforderungsfrequenz oder upgraden Sie Ihren Plan  |

## Nächste Schritte

<CardGroup cols={3}>
  <Card title="Token Transfers" icon="arrow-right-arrow-left" href="/docs/de/wallet-api/transfers">
    Eine reine Überweisungsansicht mit Sender-/Empfängerinformationen — einfacher als die vollständige Historie.
  </Card>

  <Card title="Wallet API Übersicht" icon="wallet" href="/docs/de/wallet-api/overview">
    Alle Wallet-API-Endpunkte und gemeinsamen Konventionen.
  </Card>

  <Card title="API-Referenz" icon="code" href="/docs/de/api-reference/wallet-api/history">
    Anfrage- und Antwortschemata für die Transaktionshistorie.
  </Card>
</CardGroup>