> ## 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 erhalten Sie alle Solana Wallet-Überweisungen

> Verfolgen Sie alle eingehenden und ausgehenden Token-Überweisungen für ein beliebiges Solana-Wallet. Sehen Sie Absender-/Empfängerinformationen, Beträge und Zeitstempel für die komplette Transferhistorie.

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

## Überblick

Der Token Transfers-Endpunkt ruft alle Token-Übertragungsaktivitäten für ein Solana-Wallet ab, einschließlich detaillierter Absender- und Empfängerinformationen. Im Gegensatz zur vollständigen [Transaktionshistorie](/docs/de/wallet-api/history) konzentriert sich dieser Endpunkt speziell auf Überweisungen, was ihn ideal für die Zahlungsnachverfolgung und Überwachungen von Übertragungen macht.

Der Endpunkt liefert bis zu 100 Überweisungen pro Anfrage (Standard 50). Verwenden Sie den `cursor`-Parameter mit `pagination.nextCursor`, um die nächste Seite abzurufen, und lesen Sie `pagination.hasMore`, um zu wissen, wann mehr Ergebnisse verfügbar sind.

## Wann man dies verwenden sollte

Verwenden Sie die Token Transfers API, wenn Sie:

* **Zahlungen nachverfolgen**: Überwachen eingehender Zahlungen für Zahlungsabwickler.
* **Einen Überweisungs-Feed erstellen**: Zeigen Sie einen einfachen "gesendet/empfangen"-Aktivitäts-Feed an.
* **Bestimmte Tokens überwachen**: Verfolgen Sie Transfers eines bestimmten Tokens (z.B. USDC-Zahlungen).
* **Gegenparteien identifizieren**: Sehen Sie, wer Tokens gesendet oder empfangen hat.
* **Belege generieren**: Erstellen Sie Zahlungsbelege mit Absender-/Empfängerangaben.
* **Verdächtige Aktivitäten erkennen**: Überwachen Sie ungewöhnliche Übertragungsmuster.

## Schnellstart

### Basisabfrage für Übertragungen

Abrufen der letzten eingehenden und ausgehenden Überweisungen:

<Tabs>
  <Tab title="JavaScript">
    ```javascript theme={"system"}
    const getWalletTransfers = async (address) => {
      const url = `https://api.helius.xyz/v1/wallet/${address}/transfers?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} transfers`);

      // Display recent transfers
      data.data.forEach(transfer => {
        const date = new Date(transfer.timestamp * 1000).toLocaleString();
        const direction = transfer.direction === 'in' ? 'Received' : 'Sent';
        const counterparty = transfer.counterparty.slice(0, 8) + '...';

        console.log(`\n${direction} - ${date}`);
        console.log(`Amount: ${transfer.amount} ${transfer.symbol || transfer.mint.slice(0, 8) + '...'}`);
        console.log(`${transfer.direction === 'in' ? 'From' : 'To'}: ${counterparty}`);
        console.log(`Signature: ${transfer.signature.slice(0, 20)}...`);
      });

      return data;
    };

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

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

    def get_wallet_transfers(address: str):
        url = f"https://api.helius.xyz/v1/wallet/{address}/transfers"
        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'])} transfers")

        # Display recent transfers
        for transfer in data['data']:
            date = datetime.fromtimestamp(transfer['timestamp']).strftime('%Y-%m-%d %H:%M:%S')
            direction = 'Received' if transfer['direction'] == 'in' else 'Sent'
            counterparty = transfer['counterparty'][:8] + '...'
            symbol = transfer.get('symbol') or transfer['mint'][:8] + '...'

            print(f"\n{direction} - {date}")
            print(f"Amount: {transfer['amount']} {symbol}")
            print(f"{'From' if transfer['direction'] == 'in' else 'To'}: {counterparty}")
            print(f"Signature: {transfer['signature'][:20]}...")

        return data

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

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

### Nach Richtung filtern

Filtern Sie die Ergebnisse auf der Client-Seite, um nur eingehende oder ausgehende Überweisungen zu erhalten:

<Tabs>
  <Tab title="Nur eingehend">
    ```javascript theme={"system"}
    const getIncomingTransfers = async (address) => {
      const data = await getWalletTransfers(address);

      const incoming = data.data.filter(t => t.direction === 'in');

      console.log(`Received ${incoming.length} incoming transfers`);

      incoming.forEach(transfer => {
        console.log(`Received ${transfer.amount} ${transfer.symbol} from ${transfer.counterparty.slice(0, 8)}...`);
      });

      return incoming;
    };
    ```
  </Tab>

  <Tab title="Nur ausgehend">
    ```javascript theme={"system"}
    const getOutgoingTransfers = async (address) => {
      const data = await getWalletTransfers(address);

      const outgoing = data.data.filter(t => t.direction === 'out');

      console.log(`Made ${outgoing.length} outgoing transfers`);

      outgoing.forEach(transfer => {
        console.log(`Sent ${transfer.amount} ${transfer.symbol} to ${transfer.counterparty.slice(0, 8)}...`);
      });

      return outgoing;
    };
    ```
  </Tab>
</Tabs>

## Abfrageparameter

| Parameter | Typ     | Standard | Beschreibung                                               |
| --------- | ------- | -------- | ---------------------------------------------------------- |
| `limit`   | integer | 50       | Maximale Anzahl der zurückzugebenden Überweisungen (1-100) |
| `cursor`  | string  | -        | Paginierungscursor aus vorheriger Antwort                  |

## Antwortformat

```json theme={"system"}
{
  "data": [
    {
      "signature": "5wHu1qwD7Jsj3xqWjdSEJmYr3Q5f5RjXqjqQJ7jqEj7jqEj7jqEj7jqEj7jqEj7jqE",
      "timestamp": 1704067200,
      "direction": "in",
      "counterparty": "HXsKP7wrBWaQ8T2Vtjry3Nj3oUgwYcqq9vrHDM12G664",
      "mint": "So11111111111111111111111111111111111111111",
      "symbol": "SOL",
      "amount": 1.5,
      "amountRaw": "1500000000",
      "decimals": 9
    },
    {
      "signature": "4aHu2qwD8Jtj4xqWjdSEJmYr3Q5f5RjXqjqQJ7jqEj7jqEj7jqEj7jqEj7jqEj7jqE",
      "timestamp": 1704067100,
      "direction": "out",
      "counterparty": "2ojv9BAiHUrvsm9gxDe7fJSzbNZSJcxZvf8dqmWGHG8S",
      "mint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
      "symbol": "USDC",
      "amount": 100.0,
      "amountRaw": "100000000",
      "decimals": 6
    }
  ],
  "pagination": {
    "hasMore": true,
    "nextCursor": "5wHu1qwD7Jsj3xqWjdSEJmYr3Q5f5RjXqjqQJ7jqEj7jqEj7jqEj7jqEj7jqEj7jqE"
  }
}
```

### Feldnotizen

* **`direction`**: relativ zu dem Wallet, das Sie abfragen. `in` sind Tokens **empfangen** (eingehende Zahlung); `out` sind Tokens **gesendet** (ausgehende Zahlung).
* **`counterparty`**: für `in`-Überweisungen der Absender; für `out`-Überweisungen der Empfänger.
* **`amount`**: menschlich lesbarer Überweisungsbetrag, bereits geteilt durch `decimals`. Verwenden Sie dies zur Anzeige (z.B. `1.5` SOL, `100.0` USDC).
* **`amountRaw`**: derselbe Betrag als rohe Ganzzahlzeichenfolge, vor Dezimalanpassung (z.B. `"1500000000"` für 1,5 SOL). Als Zeichenfolge serialisiert, um Verlust von Gleitkommapräzision zu vermeiden. Verwenden Sie dies für On-Chain-Anweisungen oder präzise Arithmetik: `amount = parseInt(amountRaw) / 10**decimals`.
* **`mint`**: Token-Mint-Adresse (`So11111111111111111111111111111111111111111` für nativen SOL).
* **`symbol`**: Token-Symbol. Nicht alle Tokens haben eins; verwenden Sie die Mint-Adresse, wenn `symbol` `null` ist.

## Anwendungsfälle

### Zahlungshistorie für einen Händler verfolgen

Überwachen eingehender USDC-Zahlungen:

```javascript theme={"system"}
const trackMerchantPayments = async (merchantWallet) => {
  const data = await getWalletTransfers(merchantWallet);

  // Filter for incoming USDC transfers
  const usdcPayments = data.data.filter(t =>
    t.direction === 'in' &&
    t.mint === 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v' // USDC
  );

  console.log(`Received ${usdcPayments.length} USDC payments`);

  const totalReceived = usdcPayments.reduce((sum, t) => sum + t.amount, 0);
  console.log(`Total USDC Received: $${totalReceived.toFixed(2)}`);

  // Display each payment
  usdcPayments.forEach(payment => {
    const date = new Date(payment.timestamp * 1000).toLocaleString();
    console.log(`${date}: $${payment.amount} from ${payment.counterparty}`);
  });

  return {
    count: usdcPayments.length,
    total: totalReceived,
    payments: usdcPayments
  };
};
```

### Einen Zahlungsbeleg generieren

Erstellen Sie einen detaillierten Beleg für eine bestimmte Überweisung:

```javascript theme={"system"}
const generatePaymentReceipt = async (address, signature) => {
  const data = await getWalletTransfers(address);

  const transfer = data.data.find(t => t.signature === signature);

  if (!transfer) {
    console.log('Transfer not found');
    return null;
  }

  const receipt = {
    receiptId: transfer.signature.slice(0, 16),
    date: new Date(transfer.timestamp * 1000).toISOString(),
    type: transfer.direction === 'in' ? 'Payment Received' : 'Payment Sent',
    amount: `${transfer.amount} ${transfer.symbol || 'tokens'}`,
    from: transfer.direction === 'in' ? transfer.counterparty : address,
    to: transfer.direction === 'out' ? transfer.counterparty : address,
    transactionUrl: `https://orbmarkets.io/tx/${transfer.signature}`
  };

  console.log('--- PAYMENT RECEIPT ---');
  Object.entries(receipt).forEach(([key, value]) => {
    console.log(`${key}: ${value}`);
  });

  return receipt;
};
```

### Verdächtige Übertragungsmuster überwachen

Erkennen Sie ungewöhnliche Übertragungsaktivitäten:

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

  const recentTransfers = data.data.filter(t => {
    const hourAgo = Date.now() / 1000 - 3600;
    return t.timestamp > hourAgo;
  });

  // Check for high frequency
  if (recentTransfers.length > 100) {
    console.log(`Warning: ${recentTransfers.length} transfers in the last hour`);
  }

  // Check for large amounts
  const largeTransfers = recentTransfers.filter(t => {
    // Assuming USDC/stablecoins
    return t.amount > 10000 && t.decimals === 6;
  });

  if (largeTransfers.length > 0) {
    console.log(`Warning: ${largeTransfers.length} large transfers (>$10k) in the last hour`);
  }

  // Check for transfers to same address
  const counterparties = recentTransfers.map(t => t.counterparty);
  const duplicates = counterparties.filter((item, index) => counterparties.indexOf(item) !== index);

  if (duplicates.length > 5) {
    console.log(`Warning: Multiple transfers to the same address`);
  }

  return {
    recentCount: recentTransfers.length,
    largeTransfers: largeTransfers.length,
    suspiciousPatterns: duplicates.length > 5
  };
};
```

### Einen Überweisungsaktivitäts-Feed erstellen

Erstellen Sie einen benutzerfreundlichen Aktivitäts-Feed:

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

  const feed = data.data.map(transfer => {
    const date = new Date(transfer.timestamp * 1000);
    const timeAgo = getTimeAgo(date);

    return {
      id: transfer.signature,
      direction: transfer.direction,
      title: transfer.direction === 'in' ? 'Received' : 'Sent',
      subtitle: `${transfer.amount} ${transfer.symbol || 'tokens'}`,
      description: transfer.direction === 'in'
        ? `from ${transfer.counterparty.slice(0, 8)}...`
        : `to ${transfer.counterparty.slice(0, 8)}...`,
      timeAgo,
      explorerUrl: `https://orbmarkets.io/tx/${transfer.signature}`
    };
  });

  return feed;
};

function getTimeAgo(date) {
  const seconds = Math.floor((new Date() - date) / 1000);

  if (seconds < 60) return 'Just now';
  if (seconds < 3600) return `${Math.floor(seconds / 60)}m ago`;
  if (seconds < 86400) return `${Math.floor(seconds / 3600)}h ago`;
  return `${Math.floor(seconds / 86400)}d ago`;
}
```

### Zahlungen abgleichen

Abgleichen von Überweisungen mit erwarteten Zahlungen:

```javascript theme={"system"}
const reconcilePayments = async (address, expectedPayments) => {
  const data = await getWalletTransfers(address);

  const recentTransfers = data.data.filter(t =>
    t.direction === 'in' &&
    t.mint === 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v' // USDC
  );

  const reconciliation = expectedPayments.map(expected => {
    const match = recentTransfers.find(t =>
      Math.abs(t.amount - expected.amount) < 0.01 &&
      t.counterparty === expected.from
    );

    return {
      orderId: expected.orderId,
      expectedAmount: expected.amount,
      status: match ? 'Received' : 'Pending',
      receivedAmount: match?.amount,
      signature: match?.signature,
      timestamp: match?.timestamp
    };
  });

  console.log('Payment Reconciliation:');
  reconciliation.forEach(r => {
    console.log(`Order ${r.orderId}: ${r.status}`);
  });

  return reconciliation;
};

// Example usage
const expected = [
  { orderId: 'ORDER-001', amount: 100.00, from: 'ABC...' },
  { orderId: 'ORDER-002', amount: 250.50, from: 'XYZ...' }
];

reconcilePayments("86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY", expected);
```

## Paginierung

Für Wallets mit vielen Überweisungen, blättern Sie durch die Ergebnisse mit dem `cursor`-Parameter und `pagination.hasMore`:

```javascript theme={"system"}
const getAllTransfers = async (address) => {
  let allTransfers = [];
  let cursor = null;

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

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

    allTransfers = allTransfers.concat(data.data);
    cursor = data.pagination.hasMore ? data.pagination.nextCursor : null;

    console.log(`Fetched ${allTransfers.length} transfers so far...`);

  } while (cursor);

  console.log(`\nTotal transfers: ${allTransfers.length}`);
  return allTransfers;
};
```

## Beste Praktiken

* **Filtern Sie clientseitig nach bestimmten Tokens.** Die API gibt alle Token-Überweisungen zurück. Filtern Sie nach `mint`-Adresse, um bestimmte Tokens wie USDC oder SOL nachzuverfolgen.
* **Mit der Identity API kombinieren.** Verwenden Sie den [Identity](/docs/de/wallet-api/identity)-Endpunkt, um menschenlesbare Namen für bekannte Gegenparteien anzuzeigen (Börsen, Protokolle und andere).
* **Speichern Sie zuletzt durchgeführte Überweisungen im Cache.** Überweisungsdaten ändern sich nicht. Speichern Sie Ergebnisse im Cache und rufen Sie nur neue Transfers seit Ihrer letzten Abfrage ab.
* **Paginy für komplette Historie.** Implementieren Sie die Paginierung, um Wallets mit Tausenden von Überweisungen effizient zu verwalten.
* **Ein fehlendes Symbol handhaben.** Nicht alle Tokens haben ein `symbol`-Feld. Verwenden Sie die Mint-Adresse, wenn `symbol` `null` ist.

## Überweisungen vs Transaktionshistorie

| Funktion           | Überweisungen           | Transaktionshistorie            |
| ------------------ | ----------------------- | ------------------------------- |
| **Fokus**          | Nur Token-Überweisungen | Alle Transaktionstypen          |
| **Daten**          | Absender-/Empfängerinfo | Saldoänderungen für alle Tokens |
| **Anwendungsfall** | Zahlungsnachverfolgung  | Umfassendes Aktivitätsprotokoll |
| **Leistung**       | Schneller, einfacher    | Umfassender                     |

Verwenden Sie [Transfers](/docs/de/wallet-api/transfers), wenn Sie sich nur für Zahlungen interessieren. Verwenden Sie [Transaction History](/docs/de/wallet-api/history), wenn Sie vollständige Saldoänderungsdaten benötigen.

## 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        | Ratenlimit überschritten                | Reduzieren Sie die Anfragenhäufigkeit oder upgraden Sie Ihren Plan    |

## Nächste Schritte

<CardGroup cols={3}>
  <Card title="Wallet-Historie" icon="clock-rotate-left" href="/docs/de/wallet-api/history">
    Komplette Transaktionshistorie mit Saldoänderungen pro Transaktion.
  </Card>

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

  <Card title="API-Referenz" icon="code" href="/docs/de/api-reference/wallet-api/transfers">
    Anfrage- und Antwortschemata für Token-Überweisungen.
  </Card>
</CardGroup>