> ## 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. # getTransfersByAddress Übersicht und Anleitung > Abfrage von geparsten, menschenlesbaren Token- und nativen SOL-Transferobjekten für eine Solana-Adresse mit Filtern nach Mint, Zeit, Betrag und Gegenpartei. ## Übersicht [`getTransfersByAddress`](/docs/de/api-reference/rpc/http/gettransfersbyaddress) ist eine Helius-exklusive RPC-Methode, die geparste, menschenlesbare Token- und native SOL-Transferobjekte für eine Wallet-Adresse zurückgibt. Es ist nicht Teil der standardmäßigen Solana RPC. Es konzentriert sich auf Transferaktivitäten und gibt daher prägnante Transferdatensätze statt vollständiger Transaktionspayloads zurück. Jeder Datensatz wird normalisiert mit geparsten Besitzer- und Tokenkonten, Mints, Rohbeträgen, Dezimalzahlen, UI-Beträgen, Instruktionspositionen und Bestätigungsstatus, sodass Sie Bewegungen im Saldo ohne erneute Implementierung der Solana-Token-Parsierung nachvollziehen können. Diese Methode erfordert einen [Developer-Plan](/docs/de/billing/plans) oder höher und kostet 10 Credits pro Anfrage. Gibt menschenlesbare Transferdatensätze mit geparsten Konten, Beträgen, Dezimalzahlen und Transferarten zurück. Modellieren Sie SOL, WSOL, Token-2022-Gebühren, Mints, Burns und Kontoinhaberwechsel, damit Salden genau abgestimmt werden können. Engen Sie die Transferhistorie nach Mint-Adresse, Blockzeitrange oder Rohebetragsbereich ein. Filtern Sie Transfers nach Absender oder Empfänger mit `with` und `direction`. ## Wann zu verwenden Verwenden Sie `getTransfersByAddress`, wenn Sie benötigen: * Wallet-Transferhistorie für Zahlungen oder Transferüberwachung * Portfolioaktivität und Tokenbewegungsanalysen * Vertrauenswürdige Saldoabstimmung für Bücher und Buchhaltung * Gegenparteispezifische Transferberichte (wer hat was gesendet oder empfangen) * Normalisierte SOL/WSOL-, Token-2022-Gebühren-, Mint- und Burn-Behandlung ohne einen Parser zu schreiben Verwenden Sie [`getTransactionsForAddress`](/docs/de/rpc/gettransactionsforaddress) stattdessen, wenn Sie vollständige Transaktionsdaten, nur Signaturhistorie oder nicht-Transferaktivitäten benötigen. Ein allgemeines Muster ist, hier durch Transfers zu blättern und dann die zugrundeliegenden vollständigen Transaktionen mit gebündelten [`getTransaction`](/docs/de/api-reference/rpc/http/gettransaction) Aufrufen abzurufen (siehe [Vollständige Transaktionen für Transferreihen abrufen](#vollständige-transaktionen-für-transferreihen-abrufen)). ## Genauigkeit und Abstimmung `getTransfersByAddress` ist für Anwendungen entwickelt, die eine vertrauenswürdige Transferhistorie für Bücher, Zahlungsnachverfolgung, Portfolioaktivität und Saldoabstimmung benötigen. Anstatt rohe Transaktionspayloads zurückzugeben und jeden Sonderfall Ihrem Parser zu überlassen, gibt die API normalisierte Transferobjekte zurück. Die Antwort bildet explizit die Transferfälle ab, die die Solana-Historie häufig schwer nachvollziehbar machen: * Standard-SPL-Token und native SOL-Transfers. * Token-2022-Transfers mit einbehaltenen Gebühren, dargestellt als gewöhnliche `transfer` Zeilen mit separaten Gebührenfeldern. * Mints und Burns, dargestellt als Transfers mit einem `null` Absender oder Empfänger. * SOL-Einpack- und Auspackverhalten, mit einem Standardmodus, der darauf ausgelegt ist, geräuschvolle Lebenszyklusreihen zu vermeiden. * Tokenkontoinhaberwechsel über SetAuthority. * Token-2022 einbehaltene Gebührenabhebungen. * Zwischenkontoflüsse, die als zugrunde liegende Transferdatensätze zurückgegeben werden, anstatt als geschätzte Nettobewegung zusammengefasst zu werden. Für unterstützte sichtbare Transferereignisse können Sie so Bewegungen im Saldo nachvollziehen, ohne die Solana-Token-Pasrlogik neu implementieren zu müssen. Bekannte Ausschlüsse, wie versteckte SOL-Bewegungen, die nur aus Saldoänderungen abgeleitet werden können, werden unter [Einschränkungen](#einschränkungen) erwähnt. ## Schnellstart ```javascript theme={"system"} 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: "getTransfersByAddress", params: ["86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY"] }) }); const data = await response.json(); console.log(data.result.data); ``` ## Anfrageparameter Übergeben Sie die Wallet-Inhaberadresse, nicht ein zugehöriges Tokenkonto (ATA). Die API sucht nach Transferaktivitäten für Tokenkonten, die von dieser Wallet-Inhaberin gehalten werden. Base58-kodierte Besitzer-Wallet-Adresse zur Abfrage von Transfers. Übergeben Sie die Wallet-Inhaberadresse, nicht ein zugehöriges Tokenkonto (ATA). Optionales Konfigurationsobjekt für Filterung, Paginierung, Engagement, Sortierung und SOL/WSOL-Verhalten. Nach Gegenpartei-Adresse filtern. Gibt nur Transfers zu oder von dieser Adresse zurück. Filtern Sie nach Transferrichtung relativ zu `address`. * `in`: Transfers, die von `address` empfangen wurden * `out`: Transfers, die von `address` gesendet wurden * `any`: Eingehende und ausgehende Transfers Nach Token-Mint-Adresse filtern. Verwenden Sie `So11111111111111111111111111111111111111111` für native SOL und `So11111111111111111111111111111111111111112` für WSOL. Steuert, wie native SOL und WSOL dargestellt werden. * `merged`: WSOL wird als native SOL behandelt. Ein- und Auspack-Lebenszyklusreihen werden ausgeschlossen, und WSOL-Mint-Werte werden in den nativen SOL-Mint umgeschrieben. * `separate`: WSOL wird als eigener Mint beibehalten, und Ein- und Auspack-Lebenszyklusreihen sind enthalten. Zusätzliche Filter für Betrag, Blockzeit und Slot. Maximale Anzahl der zurückzugebenden Transfers. Bereich: 1 bis 100. Cursor aus der vorherigen Antwort für Paginierung. Daten-Commitment-Level. * `finalized` * `confirmed` Der minimale Slot, bei dem die Anfrage ausgewertet werden kann Ergebnisreihenfolge. * `desc`: neueste zuerst * `asc`: älteste zuerst ## Antwort ```json theme={"system"} { "jsonrpc": "2.0", "id": "1", "result": { "data": [ { "signature": "5GEX7Q3X5Q8yJGbKYoR7mtzQmG8tpoEwzjPgqVmn3y5xg3yKwqXcDdN5YVcc9V6vA4TuH5iM6FHRVhTxvz4AX2zG", "slot": 315073428, "blockTime": 1736159420, "type": "transfer", "fromUserAccount": "7hPhaUpydpvm8wtiS3k4LPZKUmivQRs7YQmpE1hFshHx", "toUserAccount": "86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY", "fromTokenAccount": "HcvK3EJ74iM9g11cUgsaPvLSrhCvCwcrWxBNd87LsC1x", "toTokenAccount": "CBcYniR9G9CN3zGMnwNE4SWbqkYWvCFVreEob9xHnQCY", "mint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", "amount": "2500000", "decimals": 6, "uiAmount": "2.5", "confirmationStatus": "finalized", "transactionIdx": 35, "instructionIdx": 1, "innerInstructionIdx": 0 } ], "paginationToken": "315073428:35:1:0:splTransfer" } } ``` ### Antwortfeld Details * `fromUserAccount` und `toUserAccount` sind immer vorhanden. Wenn eine Seite nicht existiert, ist der Wert `null`. * `fromTokenAccount` und `toTokenAccount` sind nur enthalten, wenn Token-Kontopunkte für die Zeile von Bedeutung sind. Sie werden vollständig für native SOL-Transfers weggelassen. * Mint-Transfers sind einseitig: `fromUserAccount` ist `null`, und sie können nur als eingehende Transfers für den Empfänger zurückgegeben werden. * Burn-Transfers sind einseitig: `toUserAccount` ist `null`, und sie können nur als ausgehende Transfers für den brennenden Besitzer zurückgegeben werden. ## Filter Verwenden Sie Vergleichsfilter für numerische Bereichsabfragen. Alle Vergleichsfelder sind optional und können kombiniert werden. ```json theme={"system"} { "gt": 1000000, "gte": 1000000, "lt": 1000000000, "lte": 1000000000 } ``` | Filter | Typ | Beschreibung | | ----------- | ------------------ | -------------------------------------- | | `amount` | `ComparisonFilter` | Roher Transferbetrag, nicht UI-Betrag. | | `blockTime` | `ComparisonFilter` | Block-Zeitstempel in Unix-Sekunden. | | `slot` | `ComparisonFilter` | Slot-Nummer. | ## Transferarten Das Feld `type` identifiziert das durch jede Reihe dargestellte Transferverhalten. | Typ | Beschreibung | `fromUserAccount` | `toUserAccount` | | --------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------- | ------------------------ | | `transfer` | Standard-Token oder SOL-Transfer zwischen zwei Wallets. | Absender | Empfänger | | `mint` | Neue Tokens, die zu einer Wallet gemintet wurden. | `null` | Empfänger | | `burn` | Tokens wurden dauerhaft zerstört. | Absender | `null` | | `wrap` | SOL wurde in WSOL eingepackt. Standardmäßig in `solMode: "merged"` ausgeschlossen. | `null` | Besitzer | | `unwrap` | WSOL wurde wieder in native SOL ausgepackt oder Miete wurde von der Schließung eines Token-Kontos zurückgewonnen. Standardmäßig in `solMode: "merged"` ausgeschlossen. | Besitzer | `null` oder Lamport-Ziel | | `changeOwner` | Tokenkonto-Inhaber wurde mit SetAuthority geändert. | Alter Besitzer | Neuer Besitzer | | `withdrawWithheldFee` | Token-2022 einbehaltene Gebühren von einem Mint oder Konten gesammelt. | `null` | Gebührenempfänger | ### Transferarten und Anweisungen | Transferart | Abgedeckte Anweisungen | Standardmäßige Sichtbarkeit | | --------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------- | | `transfer` | `SystemProgram::Transfer`, `SystemProgram::TransferWithSeed`, `SystemProgram::WithdrawNonceAccount`, `SystemProgram::CreateAccount`, `SystemProgram::CreateAccountWithSeed`, `SystemProgram::CreateAccountAllowPrefund` | Immer | | `transfer` | `Token::Transfer`, `Token::TransferChecked`, `Token-2022::Transfer`, `Token-2022::TransferChecked` | Immer | | `transfer` | `Token-2022::TransferCheckedWithFee`, mit `feeAmount` und `feeUiAmount` Feldern | Immer | | `mint` | `Token::MintTo`, `Token::MintToChecked` | Immer | | `burn` | `Token::Burn`, `Token::BurnChecked` | Immer | | `wrap` | `Token::SyncNative`, `Token::InitializeAccount`, `Token::InitializeAccount2`, `Token::InitializeAccount3` bei Verwendung für WSOL-Lebenszyklusverwaltung | `solMode: "separate"` nur | | `unwrap` | `Token::CloseAccount` bei WSOL mit einem Guthaben von mehr als null | `solMode: "separate"` nur | | `unwrap` | `Token::CloseAccount` Mietrückgewinnung für nicht-WSOL-Tokenkonten oder WSOL-Konten mit null Token-Guthaben | `solMode: "separate"` nur | | `changeOwner` | `Token::SetAuthority(AccountOwner)` | Immer | | `withdrawWithheldFee` | `Token-2022::WithdrawWithheldTokensFromMint`, `Token-2022::WithdrawWithheldTokensFromAccounts` | Immer | ## SOL und wSOL Verhalten SOL existiert auf Solana in zwei Formen, die häufig zusammen in realen Benutzeraktivitäten auftreten: * **Native SOL** ist das native Asset der Chain. Es existiert direkt in einer Wallet oder einem Konto als Lamports. Ein SOL sind 1.000.000.000 Lamports. * **Wrapped SOL (WSOL, oft als wSOL geschrieben)** ist eine SPL-Token-Darstellung von SOL. Es verwendet den WSOL-Mint `So11111111111111111111111111111111111111112` und lebt in einem Tokenkonto, wie USDC oder jeder andere SPL-Token. Benutzer und Anwendungen wickeln SOL ein, wenn sie SOL benötigen, um sich wie ein SPL-Token zu verhalten, normalerweise für DeFi, Swaps, tokenkontenbasierte Buchhaltung oder Programmschnittstellen, die nur SPL-Tokens akzeptieren. Das Einwickeln finanziert typischerweise ein Tokenkonto mit nativem SOL und synchronisiert es in WSOL. Das Auswickeln schließt das WSOL-Tokenkonto und gibt das SOL an ein Lamport-Ziel zurück. Dieser Lebenszyklus kann eine verwirrende Historie schaffen, wenn Sie versuchen, eine einfache Frage zu beantworten wie "Wie viel SOL wurde zwischen dieser Wallet und jemand anderem bewegt?". Ein Ein- oder Auswickeln bewegt oft SOL zwischen von demselben Besitzer kontrollierten Konten. Wenn diese Lebenszyklusreihen standardmäßig als gewöhnliche Transfers gezeigt werden, können Anwendungen die Aktivität doppelt zählen oder interne Buchungen als externe Zahlungen anzeigen. Standardmäßig verwendet `getTransfersByAddress` `solMode: "merged"`. In diesem Modus: * Native SOL und WSOL werden als ein SOL-Asset betrachtet, wenn nach `So11111111111111111111111111111111111111111` abgefragt wird. * WSOL-Transferreihen werden auf den nativen SOL-Mint normalisiert, sodass SOL-nominierte Historie einfacher abzustimmen ist. * Ein- und Auspack-Lebenszyklusreihen sind ausgeschlossen, da sie normalerweise Bewegungen zwischen von demselben Besitzer kontrollierten Konten darstellen, nicht eine Zahlung an einen anderen Benutzer. * SOL- und WSOL-Transfers zwischen verschiedenen Besitzern werden dennoch als Transfers dargestellt. * Miete, die von `CloseAccount` zurückgewonnen wurde, wird als native SOL-`unwrap`-Reihe dargestellt, wenn Schließungskonto-Lebenszyklusreihen zurückgegeben werden. Verwenden Sie `solMode: "separate"`, wenn Sie WSOL als eigenständigen SPL-Token-Mint benötigen oder Ein- und Auspack-Lebenszyklusdatensätze inspizieren möchten. In diesem Modus behält WSOL den Mint `So11111111111111111111111111111111111111112`, und Ein-/Auspackdatensätze werden mit `type: "wrap"` oder `type: "unwrap"` zurückgegeben. Bei WSOL-Kontenschließungen in `solMode: "separate"` stellen `unwrap`-Datensätze für den WSOL-Mint das verbleibende WSOL-Token-Guthaben dar, das als SOL zurückgegeben wird. Miete, die vom geschlossenen Tokenkonto zurückerstattet wird, wird als separate native SOL-`unwrap`-Reihe zurückgegeben. ## Token-2022 Transfergebühren Token-2022 `TransferCheckedWithFee` Anweisungen werden als ein Transferdatensatz mit `type: "transfer"` dargestellt. Der Zielbetrag wird in `amount` zurückgegeben; einbehaltene Gebührendetails werden in `feeAmount` und `feeUiAmount` zurückgegeben. Bei Transfers mit Gebühren wird die Quelle `amount + feeAmount` belastet, während das Ziel `amount` gutgeschrieben wird. ```json theme={"system"} { "signature": "WcvF2eFxArpqRJySzDuiP6Xw8BMprWytMpYCxk2ExBt5C1WyxWzDWcCWXW8iKQVYR9AtdQxPE1uu1SMEZvbbhdr", "slot": 409259683, "blockTime": 1774635210, "type": "transfer", "fromUserAccount": "5aZZ4duJUKiMsJN9vRsoAn4SDX7agvKu7Q3QdFWRfWze", "toUserAccount": "FESSvM1cVUchc13XQY8e41oeYxMnyqQNYVZwoznfJsTo", "fromTokenAccount": "3VUYGjYktCzNhDVymNb3Z1iHewtfPFRvdA53qSWuxdXy", "toTokenAccount": "51cEFBA1virMuPqHXvNGs8FKKTMqeEVKzugv1hqPU2Zc", "mint": "CKfatsPMUf8SkiURsDXs7eK6GWb4Jsd6UDbs7twMCWxo", "amount": "48650000", "decimals": 5, "uiAmount": "486.5", "feeAmount": "13450000", "feeUiAmount": "134.5", "confirmationStatus": "finalized", "transactionIdx": 1315, "instructionIdx": 4, "innerInstructionIdx": 0 } ``` ## Beispiele ### Nach USDC filtern ```json theme={"system"} { "jsonrpc": "2.0", "id": "1", "method": "getTransfersByAddress", "params": [ "86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY", { "mint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v" } ] } ``` ### Eingehende Transfers von einem Absender ```json theme={"system"} { "jsonrpc": "2.0", "id": "1", "method": "getTransfersByAddress", "params": [ "86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY", { "with": "7hPhaUpydpvm8wtiS3k4LPZKUmivQRs7YQmpE1hFshHx", "direction": "in" } ] } ``` ### Betrag und Zeitbereich ```json theme={"system"} { "jsonrpc": "2.0", "id": "1", "method": "getTransfersByAddress", "params": [ "86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY", { "mint": "So11111111111111111111111111111111111111112", "filters": { "amount": { "gte": 1000000000, "lt": 10000000000 }, "blockTime": { "gte": 1735718400, "lt": 1738396800 } } } ] } ``` ### Paginierte Anfrage ```json theme={"system"} { "jsonrpc": "2.0", "id": "1", "method": "getTransfersByAddress", "params": [ "86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY", { "limit": 50, "paginationToken": "315069220:308:2:1:splTransfer" } ] } ``` ### Vollständige Transaktionen für Transferreihen abrufen `getTransfersByAddress` gibt geparste Transferreihen zurück, nicht vollständige Transaktionspayloads. Wenn Sie die vollständige Transaktion für jeden Transfer benötigen, blättern Sie zuerst durch die Transfers, deduplizieren Sie nach `signature`, und rufen Sie dann die vollständigen Transaktionen mit gebündelten [`getTransaction`](/docs/de/api-reference/rpc/http/gettransaction)-Aufrufen ab. `getTransfersByAddress` ist nicht verarbeitbar über mehrere Besitzeradressen hinweg. Abfragen Sie eine Besitzeradresse nach der anderen, dann bündeln Sie die resultierenden `getTransaction`-Anfragen nach Signatur. Eine einzelne Transaktion kann mehrere Transferreihen auslösen, daher deduplizieren Sie immer Signaturen, bevor Sie Transaktionen abrufen. ```javascript theme={"system"} const API_KEY = "YOUR_API_KEY"; const RPC_URL = `https://mainnet.helius-rpc.com/?api-key=${API_KEY}`; const OWNER_ADDRESS = "86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY"; async function rpc(method, params) { const response = await fetch(RPC_URL, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ jsonrpc: "2.0", id: "1", method, params }) }); const body = await response.json(); if (body.error) { throw new Error(body.error.message); } return body.result; } async function getAllTransfers(address) { const transfers = []; let paginationToken; do { const result = await rpc("getTransfersByAddress", [ address, { limit: 100, ...(paginationToken ? { paginationToken } : {}) } ]); transfers.push(...result.data); paginationToken = result.paginationToken; } while (paginationToken); return transfers; } async function getTransactionsInBatches(signatures, batchSize = 100) { const transactions = []; for (let i = 0; i < signatures.length; i += batchSize) { const batch = signatures.slice(i, i + batchSize).map((signature, index) => ({ jsonrpc: "2.0", id: `${i + index}`, method: "getTransaction", params: [ signature, { encoding: "jsonParsed", maxSupportedTransactionVersion: 1 } ] })); const response = await fetch(RPC_URL, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(batch) }); const results = await response.json(); for (const item of results) { if (item.error) { throw new Error(item.error.message); } transactions.push(item.result); } } return transactions; } const transfers = await getAllTransfers(OWNER_ADDRESS); const signatures = [...new Set(transfers.map((transfer) => transfer.signature))]; const transactions = await getTransactionsInBatches(signatures); console.log(`Fetched ${transfers.length} transfer rows`); console.log(`Fetched ${transactions.length} unique transactions`); ``` ## Einschränkungen * Fehlgeschlagene Transaktionen sind in V1 nicht enthalten. * Verborgene SOL-Bewegungen, die nur aus Saldoänderungen abgeleitet werden, werden in V1 nicht unterstützt. * `harvestWithheldTokensToMint` wird in V1 nicht unterstützt, da es den gesammelten Betrag nicht angibt. * Zwischenkontoflüssen wird nicht reduziert. Wenn eine Transaktion Mittel durch Zwischenkonten bewegt, werden die zugrunde liegenden Transferdatensätze zurückgegeben. * Nicht verarbeitbar über mehrere Besitzeradressen hinweg. Abfragen Sie einen Besitzer nach dem anderen. ## Nächste Schritte Vollständige Transaktionshistorie mit Filterung, Sortierung und Tokenkonto-Unterstützung. Vollständiges Anfragen- und Antwortschema für getTransfersByAddress. Füllen Sie die Transferdaten nach und synchronisieren Sie sie in Ihren eigenen Index. Vergleichen Sie alle Solana-Historische-Daten-Methoden.