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

# Ringkasan dan Tutorial getTransactionsForAddress

> Pelajari cara mengkueri riwayat transaksi Solana dengan pemfilteran lanjutan, pengurutan dua arah, dan paginasi efisien menggunakan metode RPC eksklusif Helius ini.

## Ringkasan

[`getTransactionsForAddress`](/docs/id/api-reference/rpc/http/gettransactionsforaddress) adalah metode RPC eksklusif Helius yang menampilkan riwayat transaksi suatu alamat dengan pemfilteran lanjutan, pengurutan fleksibel, dan paginasi efisien. Metode ini bukan bagian dari RPC Solana standar.

Tidak seperti `getSignaturesForAddress`, yang hanya menampilkan tanda tangan dan melewati akun token terkait, `getTransactionsForAddress` dapat menampilkan data transaksi lengkap, termasuk aktivitas associated token account (ATA) milik dompet, dalam satu panggilan. Karena itu, metode ini menjadi cara tercepat untuk mendapatkan riwayat lengkap suatu alamat guna melakukan backfill, pengindeksan, dan analitik.

Metode ini menampilkan hingga 1.000 transaksi lengkap per panggilan.

<CardGroup cols={2}>
  <Card title="Flexible sorting" icon="arrows-up-down">
    Urutkan secara kronologis (terlama lebih dahulu) atau terbalik (terbaru lebih dahulu).
  </Card>

  <Card title="Advanced filtering" icon="filter">
    Filter berdasarkan rentang waktu, slot, tanda tangan, status, dan transfer token.
  </Card>

  <Card title="Full transaction data" icon="database">
    Dapatkan detail transaksi lengkap dalam satu panggilan tanpa memerlukan getTransaction lanjutan.
  </Card>

  <Card title="Token accounts" icon="layer-group">
    Sertakan transaksi untuk akun token terkait milik suatu alamat.
  </Card>
</CardGroup>

## Kapan metode ini digunakan

Gunakan `getTransactionsForAddress` ketika Anda memerlukan:

* Riwayat token dompet lengkap, termasuk akun token terkait
* Backfill cepat dalam satu panggilan untuk pengindeks atau pipeline data
* Analisis dan pelaporan transaksi berdasarkan waktu atau slot
* Pemfilteran status untuk hanya menyimpan transaksi yang berhasil atau gagal
* Pemutaran ulang riwayat secara kronologis (urutan dari terlama)
* Analisis peluncuran token: transaksi mint pertama dan pemegang awal
* Riwayat pendanaan dompet dan penemuan pihak lawan
* Laporan kepatuhan dan audit untuk periode waktu tertentu

Untuk riwayat yang telah diuraikan dan hanya mencakup transfer (pembayaran, rekonsiliasi saldo), gunakan [`getTransfersByAddress`](/docs/id/rpc/gettransfersbyaddress).

### Dukungan jaringan

| Jaringan | Didukung | Periode Retensi |
| -------- | -------- | --------------- |
| Mainnet  | Ya       | Tanpa batas     |
| Devnet   | Ya       | 2 minggu        |
| Testnet  | Tidak    | N/A             |

## Mulai cepat

<Steps>
  <Step title="Get your API key">
    Dapatkan kunci API Anda dari [Dasbor Helius](https://dashboard.helius.dev/api-keys).
  </Step>

  <Step title="Query with advanced features">
    Dapatkan semua transaksi yang berhasil untuk suatu dompet di antara dua tanggal, diurutkan secara kronologis:

    ```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="Understand the parameters">
    Contoh ini menunjukkan fitur-fitur utama:

    * **transactionDetails**: atur ke `'full'` untuk mendapatkan data transaksi lengkap dalam satu panggilan
    * **sortOrder**: gunakan `'asc'` untuk urutan kronologis (terlama lebih dahulu) atau `'desc'` untuk yang terbaru lebih dahulu
    * **filters.blockTime**: atur rentang waktu dengan `gte` (lebih besar dari atau sama dengan) dan `lte` (lebih kecil dari atau sama dengan)
    * **filters.status**: filter agar hanya menyertakan transaksi `'succeeded'` atau `'failed'`
    * **filters.tokenAccounts**: sertakan transfer, mint, dan burn untuk akun token terkait
  </Step>
</Steps>

## Parameter permintaan

<ParamField body="address" type="string" required>
  Kunci publik akun berenkode base-58 yang riwayat transaksinya akan dikueri
</ParamField>

<ParamField body="transactionDetails" type="string" default="signatures">
  Tingkat detail transaksi yang ditampilkan:

  * `signatures`: Informasi tanda tangan dasar (lebih cepat)
  * `full`: Data transaksi lengkap (menghilangkan kebutuhan akan panggilan getTransaction, mendukung batas hingga 1.000)
</ParamField>

<ParamField body="sortOrder" type="string" default="desc">
  Urutan hasil:

  * `desc`: Terbaru lebih dahulu (default)
  * `asc`: Terlama lebih dahulu (kronologis, cocok untuk analisis historis)
</ParamField>

<ParamField body="limit" type="number" default="1000">
  Jumlah maksimum transaksi yang ditampilkan:

  * Hingga 1000 saat `transactionDetails: "signatures"`
  * Hingga 1000 saat `transactionDetails: "full"`
</ParamField>

<ParamField body="paginationToken" type="string">
  Token paginasi dari respons sebelumnya (format: `"slot:position"`)
</ParamField>

<ParamField body="commitment" type="string" default="finalized">
  Tingkat komitmen: `finalized` atau `confirmed`. Komitmen `processed` tidak didukung.
</ParamField>

<ParamField body="filters" type="object">
  Opsi pemfilteran lanjutan untuk mempersempit hasil.
</ParamField>

<ParamField body="filters.slot" type="object">
  Filter berdasarkan nomor slot menggunakan operator perbandingan: `gte`, `gt`, `lte`, `lt`

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

<ParamField body="filters.blockTime" type="object">
  Filter berdasarkan stempel waktu Unix menggunakan operator perbandingan: `gte`, `gt`, `lte`, `lt`, `eq`

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

<ParamField body="filters.signature" type="object">
  Filter berdasarkan tanda tangan transaksi menggunakan operator perbandingan: `gte`, `gt`, `lte`, `lt`

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

<ParamField body="filters.status" type="string">
  Filter berdasarkan status keberhasilan/kegagalan transaksi:

  * `succeeded`: Hanya transaksi yang berhasil
  * `failed`: Hanya transaksi yang gagal
  * `any`: Transaksi yang berhasil dan gagal (default)

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

<ParamField body="filters.tokenAccounts" type="string" default="none">
  Filter transaksi untuk akun token terkait:

  * `none`: Hanya tampilkan transaksi yang merujuk alamat yang diberikan (default)
  * `balanceChanged`: Tampilkan transaksi yang merujuk alamat yang diberikan atau mengubah saldo akun token milik alamat tersebut (direkomendasikan)
  * `all`: Tampilkan transaksi yang merujuk alamat yang diberikan atau akun token apa pun milik alamat tersebut

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

<ParamField body="filters.tokenTransfer" type="object">
  Filter agar hanya menyertakan transaksi ketika alamat yang dikueri berpartisipasi dalam transfer token yang cocok dengan pihak lawan, arah, mint, atau rentang jumlah mentah. Semua bidang bersifat opsional dan digabungkan dengan semantik AND.

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

<ParamField body="filters.tokenTransfer.with" type="string">
  Alamat pihak lawan. Mencocokkan transfer yang sisi lainnya merupakan alamat ini.
</ParamField>

<ParamField body="filters.tokenTransfer.direction" type="string" default="any">
  Filter berdasarkan arah transfer relatif terhadap alamat yang dikueri:

  * `in`: Transfer yang diterima alamat yang dikueri
  * `out`: Transfer yang dikirim alamat yang dikueri
  * `any`: Transfer masuk dan keluar
</ParamField>

<ParamField body="filters.tokenTransfer.mint" type="string">
  Mint token yang digunakan sebagai filter.
</ParamField>

<ParamField body="filters.tokenTransfer.amount" type="object">
  Perbandingan jumlah menggunakan jumlah mentah on-chain, bukan jumlah UI atau jumlah yang telah disesuaikan dengan desimal. Mendukung `gt`, `gte`, `lt`, dan `lte`.
</ParamField>

<ParamField body="encoding" type="string">
  Format enkode untuk data transaksi (hanya berlaku saat `transactionDetails: "full"`). Sama seperti API `getTransaction`. Opsi: `json`, `jsonParsed`, `base64`, `base58`
</ParamField>

<ParamField body="maxSupportedTransactionVersion" type="number">
  Atur versi transaksi maksimum yang akan ditampilkan. Jika dihilangkan, hanya transaksi lama yang akan ditampilkan. Atur ke `1` untuk menyertakan transaksi lama, v0, dan v1.
</ParamField>

<ParamField body="minContextSlot" type="number">
  Slot minimum tempat permintaan dapat dievaluasi
</ParamField>

### Pengukuran penggunaan

Respons yang berhasil diukur berdasarkan data yang ditampilkan:

| Jenis respons          | Kredit                                                                              |
| ---------------------- | ----------------------------------------------------------------------------------- |
| Transaksi lengkap      | 10 kredit per 100 transaksi yang ditampilkan, dibulatkan ke atas; minimum 10 kredit |
| Hanya tanda tangan     | Tetap 10 kredit, berapa pun jumlahnya                                               |
| Respons API yang gagal | Gratis                                                                              |

## Respons

Struktur respons bergantung pada `transactionDetails`. Mode tanda tangan menampilkan catatan tanda tangan yang ringan; mode lengkap menampilkan objek transaksi dan metadata lengkap.

<Tabs>
  <Tab title="Signatures Response">
    ```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="Full Transaction Response">
    ```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>

### Bidang respons

| Bidang               | Jenis          | Deskripsi                                                                                                                                                                                                                                                     |
| -------------------- | -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `signature`          | string         | Tanda tangan transaksi (berenkode base-58). Hanya dalam mode tanda tangan.                                                                                                                                                                                    |
| `slot`               | number         | Slot yang berisi blok dengan transaksi ini.                                                                                                                                                                                                                   |
| `transactionIndex`   | number         | Indeks berbasis nol untuk transaksi di dalam bloknya. Berguna untuk pengurutan transaksi dan rekonstruksi blok.                                                                                                                                               |
| `blockTime`          | number \| null | Perkiraan waktu produksi sebagai stempel waktu Unix (detik sejak epoch).                                                                                                                                                                                      |
| `err`                | object \| null | Kesalahan jika transaksi gagal, null jika berhasil. Hanya dalam mode tanda tangan.                                                                                                                                                                            |
| `memo`               | string \| null | Memo yang terkait dengan transaksi. Hanya dalam mode tanda tangan.                                                                                                                                                                                            |
| `confirmationStatus` | string         | Status konfirmasi klaster transaksi. Hanya dalam mode tanda tangan.                                                                                                                                                                                           |
| `transaction`        | object         | Data transaksi lengkap. Hanya dalam mode lengkap.                                                                                                                                                                                                             |
| `meta`               | object         | Metadata status transaksi — strukturnya sama seperti `getTransaction`, termasuk `err`, `fee`, `preBalances`/`postBalances`, `preTokenBalances`/`postTokenBalances`, `innerInstructions`, `logMessages`, dan `computeUnitsConsumed`. Hanya dalam mode lengkap. |
| `paginationToken`    | string \| null | Token untuk mengambil halaman berikutnya, atau null jika tidak ada hasil lainnya.                                                                                                                                                                             |

Bidang `transactionIndex` bersifat eksklusif untuk `getTransactionsForAddress`. Endpoint serupa lainnya seperti `getSignaturesForAddress`, `getTransaction`, dan `getTransactions` tidak menyertakan bidang ini.

Dalam mode lengkap, `meta` adalah objek metadata transaksi lengkap — strukturnya identik dengan yang ditampilkan oleh `getTransaction`. Objek ini mencakup `preTokenBalances` dan `postTokenBalances`, sehingga Anda dapat menghitung perubahan saldo token (misalnya, untuk mendeteksi swap) langsung dari respons tanpa panggilan lanjutan.

## Filter

Anda dapat menggunakan operator perbandingan untuk `slot`, `blockTime`, dan `signature`, serta filter khusus `status`, `tokenAccounts`, dan `tokenTransfer`. Menggabungkan beberapa filter akan mempersempit hasil ke irisannya.

### Operator perbandingan

Operator ini bekerja seperti kueri basis data agar Anda dapat mengontrol rentang data secara presisi.

| Operator | Nama Lengkap                      | Deskripsi                                           | Contoh                          |
| -------- | --------------------------------- | --------------------------------------------------- | ------------------------------- |
| `gte`    | Lebih Besar dari atau Sama Dengan | Sertakan nilai ≥ nilai yang ditentukan              | `slot: { gte: 100 }`            |
| `gt`     | Lebih Besar dari                  | Sertakan nilai > nilai yang ditentukan              | `blockTime: { gt: 1641081600 }` |
| `lte`    | Lebih Kecil dari atau Sama Dengan | Sertakan nilai ≤ nilai yang ditentukan              | `slot: { lte: 2000 }`           |
| `lt`     | Lebih Kecil dari                  | Sertakan nilai \< nilai yang ditentukan             | `blockTime: { lt: 1641168000 }` |
| `eq`     | Sama Dengan                       | Sertakan nilai yang sama persis (hanya `blockTime`) | `blockTime: { eq: 1641081600 }` |

### Filter enum

| Filter          | Deskripsi                                           | Nilai                                |
| --------------- | --------------------------------------------------- | ------------------------------------ |
| `status`        | Filter transaksi berdasarkan keberhasilan/kegagalan | `succeeded`, `failed`, atau `any`    |
| `tokenAccounts` | Filter transaksi untuk akun token terkait           | `none`, `balanceChanged`, atau `all` |

Contoh filter gabungan:

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

### Akun token terkait

Di Solana, dompet tidak menyimpan token secara langsung. Sebaliknya, dompet memiliki akun token, dan akun token tersebut menyimpan token. Ketika seseorang mengirim USDC kepada Anda, token itu masuk ke akun token USDC Anda, bukan ke alamat dompet utama Anda.

Metode ini unik karena dapat mengkueri **riwayat token lengkap**, termasuk associated token account (ATA) milik dompet. Metode RPC native seperti `getSignaturesForAddress` tidak menyertakan ATA.

Filter `tokenAccounts` mengontrol perilaku ini:

* **`none`** (default): Hanya menampilkan transaksi yang secara langsung merujuk alamat dompet. Gunakan ini jika Anda hanya membutuhkan interaksi dompet langsung.
* **`balanceChanged`** (direkomendasikan): Menampilkan transaksi yang merujuk alamat dompet atau mengubah saldo akun token milik dompet. Opsi ini menyaring spam dan operasi yang tidak terkait, seperti pengumpulan biaya atau delegasi, sehingga Anda mendapatkan tampilan aktivitas dompet penting yang bersih.
* **`all`**: Menampilkan semua transaksi yang merujuk alamat dompet atau akun token apa pun milik dompet.

Filter `tokenAccounts` tidak mendukung transaksi sebelum Desember 2022. Filter ini bergantung pada metadata transfer token yang diperkenalkan ke Solana pada slot 111,491,819. Untuk mencakup aktivitas sebelumnya, lihat [solusi alternatif akun token historis](#batasan-dan-kasus-khusus).

### Filter transfer token

Filter `tokenTransfer` mempersempit hasil ke transaksi ketika alamat yang dikueri berpartisipasi dalam transfer token yang cocok dengan kriteria tertentu: pihak lawan, mint, arah, atau rentang jumlah tertentu.

Gunakan filter ini untuk menjawab pertanyaan seperti:

* Kapan dompet ini menerima USDC dari pihak lawan tertentu?
* Tampilkan setiap transfer keluar di atas 1.000 token.
* Kapan dompet ini pernah berinteraksi dengan mint tertentu ini?

Filter ini merupakan bidang opsional di dalam objek `filters` pada konfigurasi permintaan:

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

Semua bidang di dalam `tokenTransfer` bersifat opsional. Menggabungkan beberapa bidang diperlakukan sebagai AND.

| Bidang      | Jenis                        | Default | Deskripsi                                                                                                                   |
| ----------- | ---------------------------- | ------- | --------------------------------------------------------------------------------------------------------------------------- |
| `with`      | string (pubkey)              | -       | Alamat pihak lawan. Mencocokkan transfer yang sisi lainnya merupakan alamat ini.                                            |
| `direction` | `"in"` \| `"out"` \| `"any"` | `"any"` | Menentukan apakah alamat yang dikueri menerima, mengirim, atau keduanya.                                                    |
| `mint`      | string (pubkey)              | -       | Mint token yang digunakan sebagai filter.                                                                                   |
| `amount`    | object                       | -       | Perbandingan jumlah. Menggunakan jumlah mentah on-chain, bukan jumlah UI atau jumlah yang telah disesuaikan dengan desimal. |

Operator rentang jumlah:

| Operator | Arti                              |
| -------- | --------------------------------- |
| `gt`     | Benar-benar lebih besar dari      |
| `gte`    | Lebih besar dari atau sama dengan |
| `lt`     | Benar-benar lebih kecil dari      |
| `lte`    | Lebih kecil dari atau sama dengan |

Anda dapat menggabungkan operator jumlah, seperti `{ "gte": 1000000, "lte": 5000000 }` untuk rentang tertutup. `tokenTransfer` dapat digabungkan dengan filter tingkat teratas lainnya (`slot`, `blockTime`, `status`, dan `tokenAccounts`); hasil akhirnya adalah irisan.

## Contoh

### Analitik berbasis waktu

Buat laporan transaksi bulanan:

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

Proses untuk analitik:

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

### Pembuatan mint token

Temukan transaksi pembuatan mint untuk token tertentu:

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

Untuk pembuatan pool likuiditas, kueri alamat pool:

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

Ini menemukan momen yang tepat ketika mint token atau pool likuiditas dibuat, termasuk alamat pembuat dan parameter awal.

### Transaksi pendanaan

Temukan pihak yang mendanai alamat tertentu:

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

Kemudian analisis data transaksi untuk menemukan transfer SOL:

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

Beberapa transaksi pertama sering kali mengungkapkan sumber pendanaan dan dapat membantu mengidentifikasi alamat terkait atau pola pendanaan.

### Transfer token

Filter berdasarkan `tokenTransfer` untuk mengisolasi pergerakan token tertentu.

Aliran masuk USDC ke suatu alamat:

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

Transfer keluar dalam jumlah besar ke pihak lawan tertentu:

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

Digabungkan dengan rentang slot dan status:

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

## Paginasi

Jika jumlah transaksi melebihi batas Anda, gunakan `paginationToken` dari respons untuk mengambil halaman berikutnya. Token ini berupa string sederhana dalam format `"slot:position"` yang memberi tahu API tempat untuk melanjutkan.

Gunakan token paginasi dari setiap respons untuk mengambil halaman berikutnya:

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

### Beberapa alamat

Anda tidak dapat mengkueri beberapa alamat dalam satu permintaan. Setiap kueri alamat dihitung sebagai permintaan API terpisah dan diukur sesuai ketentuan. Untuk mengambil transaksi bagi beberapa alamat, kueri setiap alamat dalam rentang waktu atau slot yang sama, lalu gabungkan dan urutkan:

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

Untuk pemindaian riwayat yang lebih besar, lakukan iterasi melalui rentang waktu atau slot (misalnya, 1000 slot sekaligus) dan ulangi pola ini.

## Praktik terbaik

**Performa.** Gunakan `transactionDetails: "signatures"` saat Anda tidak memerlukan data transaksi lengkap. Gunakan ukuran halaman yang wajar untuk waktu respons yang lebih baik, dan filter berdasarkan rentang waktu atau slot tertentu untuk kueri yang lebih terarah.

**Pemfilteran.** Mulai dengan filter yang luas, lalu persempit secara bertahap. Gunakan filter berbasis waktu untuk alur kerja analitik dan pelaporan, serta gabungkan beberapa filter untuk kueri presisi yang menargetkan jenis transaksi atau periode waktu tertentu.

**Paginasi.** Simpan token paginasi saat Anda perlu melanjutkan kueri besar nanti. Pantau kedalaman paginasi untuk perencanaan performa, dan gunakan urutan menaik saat Anda perlu memutar ulang peristiwa historis secara kronologis.

**Penanganan kesalahan.** Tangani batas laju dengan baik menggunakan backoff eksponensial. Validasi alamat sebelum membuat permintaan, dan simpan hasil dalam cache jika sesuai untuk mengurangi penggunaan API.

## Batasan dan kasus khusus

Sejumlah kecil alamat diarahkan ke arsip lama, dibatasi pada fallback pemindaian slot, atau menampilkan hasil kosong. Penemuan akun token sebelum slot 111,491,819 juga memerlukan solusi alternatif. Perluas bagian di bawah untuk melihat detail lengkap.

<Accordion title="Unsupported and specially-routed addresses">
  **Diarahkan ke arsip lama.** Permintaan untuk alamat-alamat ini diarahkan ke sistem arsip lama kami.

  | Alamat                                        | Nama                                                                                                                    |
  | --------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
  | `Stake11111111111111111111111111111111111111` | [Program Stake](https://orbmarkets.io/address/Stake11111111111111111111111111111111111111/history)                      |
  | `StakeConfig11111111111111111111111111111111` | [Konfigurasi Stake](https://orbmarkets.io/address/StakeConfig11111111111111111111111111111111/history)                  |
  | `Sysvar1111111111111111111111111111111111111` | [Pemilik Sysvar](https://orbmarkets.io/address/Sysvar1111111111111111111111111111111111111/history)                     |
  | `AddressLookupTab1e1111111111111111111111111` | [Tabel Pencarian Alamat](https://orbmarkets.io/address/AddressLookupTab1e1111111111111111111111111/history)             |
  | `BPFLoaderUpgradeab1e11111111111111111111111` | [BPF Loader yang Dapat Ditingkatkan](https://orbmarkets.io/address/BPFLoaderUpgradeab1e11111111111111111111111/history) |

  **Fallback pemindaian slot.** Permintaan untuk alamat-alamat ini diteruskan ke sistem arsip baru kami dan dapat dikueri melalui pendekatan pemindaian per slot (maksimum 100 slot). Namun, data ini tidak diindeks.

  | Alamat                                        | Nama                                                                                                    |
  | --------------------------------------------- | ------------------------------------------------------------------------------------------------------- |
  | `11111111111111111111111111111111`            | [Program Sistem](https://orbmarkets.io/address/11111111111111111111111111111111/history)                |
  | `ComputeBudget111111111111111111111111111111` | [Anggaran Komputasi](https://orbmarkets.io/address/ComputeBudget111111111111111111111111111111/history) |
  | `MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr` | [Program Memo](https://orbmarkets.io/address/MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr/history)       |
  | `Vote111111111111111111111111111111111111111` | [Program Vote](https://orbmarkets.io/address/Vote111111111111111111111111111111111111111/history)       |

  **Menampilkan hasil kosong (`is_reserved_address`).** Permintaan diteruskan ke sistem arsip baru kami, tetapi datanya tidak diindeks dan kueri menampilkan hasil kosong.

  | Alamat                                         | Nama                                                                                                                   |
  | ---------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
  | `BPFLoader1111111111111111111111111111111111`  | [BPF Loader (tidak digunakan lagi)](https://orbmarkets.io/address/BPFLoader1111111111111111111111111111111111/history) |
  | `BPFLoader2111111111111111111111111111111111`  | [BPF Loader](https://orbmarkets.io/address/BPFLoader2111111111111111111111111111111111/history)                        |
  | `Config1111111111111111111111111111111111111`  | [Program Konfigurasi](https://orbmarkets.io/address/Config1111111111111111111111111111111111111/history)               |
  | `Ed25519SigVerify111111111111111111111111111`  | [Program Ed25519](https://orbmarkets.io/address/Ed25519SigVerify111111111111111111111111111/history)                   |
  | `Feature111111111111111111111111111111111111`  | [Program Fitur](https://orbmarkets.io/address/Feature111111111111111111111111111111111111/history)                     |
  | `KeccakSecp256k11111111111111111111111111111`  | [Program Secp256k1](https://orbmarkets.io/address/KeccakSecp256k11111111111111111111111111111/history)                 |
  | `LoaderV411111111111111111111111111111111111`  | [Loader V4](https://orbmarkets.io/address/LoaderV411111111111111111111111111111111111/history)                         |
  | `NativeLoader1111111111111111111111111111111`  | [Loader Native](https://orbmarkets.io/address/NativeLoader1111111111111111111111111111111/history)                     |
  | `SysvarC1ock11111111111111111111111111111111`  | [Sysvar Jam](https://orbmarkets.io/address/SysvarC1ock11111111111111111111111111111111/history)                        |
  | `SysvarEpochSchedu1e111111111111111111111111`  | [Sysvar Jadwal Epoch](https://orbmarkets.io/address/SysvarEpochSchedu1e111111111111111111111111/history)               |
  | `SysvarFees111111111111111111111111111111111`  | [Sysvar Biaya](https://orbmarkets.io/address/SysvarFees111111111111111111111111111111111/history)                      |
  | `Sysvar1nstructions1111111111111111111111111`  | [Sysvar Instruksi](https://orbmarkets.io/address/Sysvar1nstructions1111111111111111111111111/history)                  |
  | `SysvarRecentB1ockHashes11111111111111111111`  | [Sysvar Blockhash Terbaru](https://orbmarkets.io/address/SysvarRecentB1ockHashes11111111111111111111/history)          |
  | `SysvarRent111111111111111111111111111111111`  | [Sysvar Sewa](https://orbmarkets.io/address/SysvarRent111111111111111111111111111111111/history)                       |
  | `SysvarRewards111111111111111111111111111111`  | [Sysvar Imbalan](https://orbmarkets.io/address/SysvarRewards111111111111111111111111111111/history)                    |
  | `SysvarS1otHashes111111111111111111111111111`  | [Sysvar Hash Slot](https://orbmarkets.io/address/SysvarS1otHashes111111111111111111111111111/history)                  |
  | `SysvarS1otHistory11111111111111111111111111`  | [Sysvar Riwayat Slot](https://orbmarkets.io/address/SysvarS1otHistory11111111111111111111111111/history)               |
  | `SysvarStakeHistory1111111111111111111111111`  | [Sysvar Riwayat Stake](https://orbmarkets.io/address/SysvarStakeHistory1111111111111111111111111/history)              |
  | `SysvarEpochRewards11111111111111111111111111` | [Sysvar Imbalan Epoch](https://orbmarkets.io/address/SysvarEpochRewards11111111111111111111111111/history)             |
  | `SysvarLastRestartS1ot1111111111111111111111`  | [Sysvar Slot Mulai Ulang Terakhir](https://orbmarkets.io/address/SysvarLastRestartS1ot1111111111111111111111/history)  |
</Accordion>

<Accordion title="Workaround: historical token account discovery (before slot 111,491,819)">
  Untuk alamat dengan aktivitas akun token sebelum slot 111,491,819, filter `tokenAccounts` tidak dapat menentukan kepemilikan karena bidang `owner` dalam metadata saldo token belum tersedia. Untuk mendapatkan hasil lengkap, Anda dapat menemukan akun token tersebut secara manual dengan menguraikan instruksi transaksi awal, lalu mengkueri `getTransactionsForAddress` secara paralel untuk masing-masing akun.

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

## Apa perbedaannya dengan getSignaturesForAddress?

Jika Anda sudah memahami metode standar `getSignaturesForAddress`, `getTransactionsForAddress` menyederhanakan alur kerja beberapa langkah menjadi satu panggilan serta menambahkan dukungan pemfilteran, pengurutan, dan akun token. Untuk konversi kode yang ada secara bertahap, lihat [panduan migrasi](/docs/id/rpc/migrate-to-gettransactionsforaddress).

### Dapatkan transaksi lengkap dalam satu panggilan

Dengan `getSignaturesForAddress`, Anda memerlukan dua langkah:

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

Dengan `getTransactionsForAddress`, Anda hanya memerlukan satu panggilan:

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

### Dapatkan riwayat token dalam satu panggilan

Dengan `getSignaturesForAddress`, Anda harus memanggil `getTokenAccountsByOwner` terlebih dahulu, lalu mengkueri setiap akun token:

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

Dengan `getTransactionsForAddress`, Anda hanya perlu mengatur `filters.tokenAccounts`:

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

### Kemampuan tambahan

<CardGroup cols={2}>
  <Card title="Chronological sorting" icon="arrow-up">
    Urutkan transaksi dari yang terlama hingga terbaru dengan `sortOrder: 'asc'`.
  </Card>

  <Card title="Time-based filtering" icon="clock">
    Filter berdasarkan rentang waktu menggunakan filter `blockTime`.
  </Card>

  <Card title="Status filtering" icon="filter">
    Dapatkan hanya transaksi yang berhasil atau gagal dengan filter `status`.
  </Card>

  <Card title="Simpler pagination" icon="list">
    Gunakan `paginationToken` sebagai pengganti tanda tangan `before`/`until` yang membingungkan.
  </Card>
</CardGroup>

## Langkah berikutnya

<CardGroup cols={2}>
  <Card title="Indexing guide" icon="layer-group" href="/docs/id/rpc/how-to-index-solana-data">
    Gunakan getTransactionsForAddress untuk melakukan backfill dan menyinkronkan indeks Solana.
  </Card>

  <Card title="getTransfersByAddress" icon="arrow-right-arrow-left" href="/docs/id/rpc/gettransfersbyaddress">
    Riwayat yang telah diuraikan dan hanya mencakup transfer untuk pembayaran dan rekonsiliasi.
  </Card>

  <Card title="API reference" icon="code" href="/docs/id/api-reference/rpc/http/gettransactionsforaddress">
    Skema permintaan dan respons lengkap untuk getTransactionsForAddress.
  </Card>

  <Card title="Historical data overview" icon="clock-rotate-left" href="/docs/id/rpc/historical-data">
    Bandingkan semua metode data historis Solana.
  </Card>
</CardGroup>