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

# Descripción general y tutorial de getTransactionsForAddress

> Aprende a consultar el historial de transacciones de Solana con filtrado avanzado, ordenamiento bidireccional y paginación eficiente mediante este método RPC exclusivo de Helius.

## Descripción general

[`getTransactionsForAddress`](/docs/es/api-reference/rpc/http/gettransactionsforaddress) es un método RPC exclusivo de Helius que devuelve el historial de transacciones de una dirección con filtrado avanzado, ordenamiento flexible y paginación eficiente. No forma parte del RPC estándar de Solana.

A diferencia de `getSignaturesForAddress`, que solo devuelve firmas y omite las cuentas de tokens asociadas, `getTransactionsForAddress` puede devolver los datos completos de las transacciones, incluida la actividad de las cuentas de tokens asociadas (ATA) de una billetera, en una sola llamada. Esto lo convierte en la forma más rápida de obtener el historial completo de una dirección para rellenar datos históricos, indexar y realizar análisis.

Este método devuelve hasta 1,000 transacciones completas por llamada.

<CardGroup cols={2}>
  <Card title="Flexible sorting" icon="arrows-up-down">
    Ordena cronológicamente (primero las más antiguas) o en orden inverso (primero las más recientes).
  </Card>

  <Card title="Advanced filtering" icon="filter">
    Filtra por intervalos de tiempo, slots, firmas, estado y transferencias de tokens.
  </Card>

  <Card title="Full transaction data" icon="database">
    Obtén los detalles completos de la transacción en una sola llamada, sin necesidad de una llamada posterior a getTransaction.
  </Card>

  <Card title="Token accounts" icon="layer-group">
    Incluye las transacciones de las cuentas de tokens asociadas a una dirección.
  </Card>
</CardGroup>

## Cuándo usarlo

Usa `getTransactionsForAddress` cuando necesites:

* El historial completo de tokens de una billetera, incluidas las cuentas de tokens asociadas
* Un relleno rápido de datos históricos en una sola llamada para un indexador o pipeline de datos
* Análisis e informes de transacciones basados en tiempo o slots
* Filtrado por estado para conservar solo las transacciones exitosas o solo las fallidas
* Reproducción histórica cronológica (orden de la más antigua a la más reciente)
* Análisis del lanzamiento de tokens: primeras transacciones de acuñación y primeros titulares
* Historial de financiamiento de billeteras y detección de contrapartes
* Informes de cumplimiento y auditoría para un periodo específico

Para obtener un historial analizado que solo incluya transferencias (pagos y conciliación de saldos), usa [`getTransfersByAddress`](/docs/es/rpc/gettransfersbyaddress).

### Compatibilidad con redes

| Red     | Compatible | Periodo de retención |
| ------- | ---------- | -------------------- |
| Mainnet | Sí         | Ilimitado            |
| Devnet  | Sí         | 2 semanas            |
| Testnet | No         | N/D                  |

## Inicio rápido

<Steps>
  <Step title="Get your API key">
    Obtén tu clave de API en el [panel de Helius](https://dashboard.helius.dev/api-keys).
  </Step>

  <Step title="Query with advanced features">
    Obtén todas las transacciones exitosas de una billetera entre dos fechas, ordenadas cronológicamente:

    ```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">
    Este ejemplo muestra las funciones principales:

    * **transactionDetails**: establécelo en `'full'` para obtener los datos completos de las transacciones en una sola llamada
    * **sortOrder**: usa `'asc'` para el orden cronológico (primero las más antiguas) o `'desc'` para mostrar primero las más recientes
    * **filters.blockTime**: define intervalos de tiempo con `gte` (mayor o igual que) y `lte` (menor o igual que)
    * **filters.status**: filtra solo las transacciones `'succeeded'` o `'failed'`
    * **filters.tokenAccounts**: incluye transferencias, acuñaciones y quemas de cuentas de tokens asociadas
  </Step>
</Steps>

## Parámetros de la solicitud

<ParamField body="address" type="string" required>
  Clave pública codificada en base 58 de la cuenta cuyo historial de transacciones quieres consultar
</ParamField>

<ParamField body="transactionDetails" type="string" default="signatures">
  Nivel de detalle de la transacción que se devolverá:

  * `signatures`: información básica de la firma (más rápido)
  * `full`: datos completos de la transacción (elimina la necesidad de llamadas a getTransaction y admite un límite de hasta 1,000)
</ParamField>

<ParamField body="sortOrder" type="string" default="desc">
  Orden de los resultados:

  * `desc`: primero los más recientes (predeterminado)
  * `asc`: primero los más antiguos (orden cronológico, ideal para análisis históricos)
</ParamField>

<ParamField body="limit" type="number" default="1000">
  Número máximo de transacciones que se devolverán:

  * Hasta 1000 cuando `transactionDetails: "signatures"`
  * Hasta 1000 cuando `transactionDetails: "full"`
</ParamField>

<ParamField body="paginationToken" type="string">
  Token de paginación de la respuesta anterior (formato: `"slot:position"`)
</ParamField>

<ParamField body="commitment" type="string" default="finalized">
  Nivel de confirmación: `finalized` o `confirmed`. No se admite el nivel `processed`.
</ParamField>

<ParamField body="filters" type="object">
  Opciones de filtrado avanzado para restringir los resultados.
</ParamField>

<ParamField body="filters.slot" type="object">
  Filtra por número de slot mediante operadores de comparación: `gte`, `gt`, `lte`, `lt`

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

<ParamField body="filters.blockTime" type="object">
  Filtra por marca de tiempo Unix mediante operadores de comparación: `gte`, `gt`, `lte`, `lt`, `eq`

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

<ParamField body="filters.signature" type="object">
  Filtra por firma de transacción mediante operadores de comparación: `gte`, `gt`, `lte`, `lt`

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

<ParamField body="filters.status" type="string">
  Filtra por el estado de éxito o fallo de la transacción:

  * `succeeded`: solo transacciones exitosas
  * `failed`: solo transacciones fallidas
  * `any`: transacciones exitosas y fallidas (predeterminado)

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

<ParamField body="filters.tokenAccounts" type="string" default="none">
  Filtra las transacciones de cuentas de tokens relacionadas:

  * `none`: devuelve solo las transacciones que hacen referencia a la dirección proporcionada (predeterminado)
  * `balanceChanged`: devuelve las transacciones que hacen referencia a la dirección proporcionada o modifican el saldo de una cuenta de tokens propiedad de esa dirección (recomendado)
  * `all`: devuelve las transacciones que hacen referencia a la dirección proporcionada o a cualquier cuenta de tokens propiedad de esa dirección

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

<ParamField body="filters.tokenTransfer" type="object">
  Filtra las transacciones en las que la dirección consultada participó en una transferencia de tokens que coincide con una contraparte, dirección de transferencia, acuñación o intervalo de importes sin procesar. Todos los campos son opcionales y se combinan con semántica AND.

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

<ParamField body="filters.tokenTransfer.with" type="string">
  Dirección de la contraparte. Coincide con transferencias cuyo otro extremo es esta dirección.
</ParamField>

<ParamField body="filters.tokenTransfer.direction" type="string" default="any">
  Filtra por la dirección de la transferencia con respecto a la dirección consultada:

  * `in`: transferencias recibidas por la dirección consultada
  * `out`: transferencias enviadas por la dirección consultada
  * `any`: transferencias entrantes y salientes
</ParamField>

<ParamField body="filters.tokenTransfer.mint" type="string">
  Acuñación del token por la que se filtrará.
</ParamField>

<ParamField body="filters.tokenTransfer.amount" type="object">
  Comparación de importes mediante el importe sin procesar en cadena, no el importe de la IU ni el ajustado por decimales. Admite `gt`, `gte`, `lt` e `lte`.
</ParamField>

<ParamField body="encoding" type="string">
  Formato de codificación de los datos de transacciones (solo se aplica cuando `transactionDetails: "full"`). Es el mismo que el de la API `getTransaction`. Opciones: `json`, `jsonParsed`, `base64`, `base58`
</ParamField>

<ParamField body="maxSupportedTransactionVersion" type="number">
  Define la versión máxima de transacción que se devolverá. Si se omite, solo se devolverán transacciones heredadas. Establécelo en `1` para incluir transacciones heredadas, v0 y v1.
</ParamField>

<ParamField body="minContextSlot" type="number">
  El slot mínimo en el que se puede evaluar la solicitud
</ParamField>

### Medición

Las respuestas exitosas se miden según lo que se devuelve:

| Tipo de respuesta             | Créditos                                                                                          |
| ----------------------------- | ------------------------------------------------------------------------------------------------- |
| Transacciones completas       | 10 créditos por cada 100 transacciones devueltas, redondeados hacia arriba; mínimo de 10 créditos |
| Solo firmas                   | 10 créditos fijos, sin importar la cantidad                                                       |
| Respuestas fallidas de la API | Gratis                                                                                            |

## Respuesta

La estructura de la respuesta depende de `transactionDetails`. El modo de firmas devuelve registros ligeros de firmas; el modo completo devuelve objetos completos de transacciones y metadatos.

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

### Campos de la respuesta

| Campo                | Tipo           | Descripción                                                                                                                                                                                                                                                                |
| -------------------- | -------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `signature`          | string         | Firma de la transacción (codificada en base 58). Solo en el modo de firmas.                                                                                                                                                                                                |
| `slot`               | number         | El slot que contiene el bloque con esta transacción.                                                                                                                                                                                                                       |
| `transactionIndex`   | number         | El índice de base cero de la transacción dentro de su bloque. Es útil para ordenar transacciones y reconstruir bloques.                                                                                                                                                    |
| `blockTime`          | number \| null | Tiempo de producción estimado como marca de tiempo Unix (segundos desde el inicio de la época).                                                                                                                                                                            |
| `err`                | object \| null | Error si la transacción falló; null si tuvo éxito. Solo en el modo de firmas.                                                                                                                                                                                              |
| `memo`               | string \| null | Memo asociado con la transacción. Solo en el modo de firmas.                                                                                                                                                                                                               |
| `confirmationStatus` | string         | Estado de confirmación del clúster de la transacción. Solo en el modo de firmas.                                                                                                                                                                                           |
| `transaction`        | object         | Datos completos de la transacción. Solo en el modo completo.                                                                                                                                                                                                               |
| `meta`               | object         | Metadatos del estado de la transacción, con la misma estructura que `getTransaction`, incluidos `err`, `fee`, `preBalances`/`postBalances`, `preTokenBalances`/`postTokenBalances`, `innerInstructions`, `logMessages` e `computeUnitsConsumed`. Solo en el modo completo. |
| `paginationToken`    | string \| null | Token para obtener la página siguiente, o null si no hay más resultados.                                                                                                                                                                                                   |

El campo `transactionIndex` es exclusivo de `getTransactionsForAddress`. Otros endpoints similares, como `getSignaturesForAddress`, `getTransaction` e `getTransactions`, no incluyen este campo.

En el modo completo, `meta` es el objeto completo de metadatos de la transacción, con una estructura idéntica a la que devuelve `getTransaction`. Incluye `preTokenBalances` e `postTokenBalances`, por lo que puedes calcular los cambios en los saldos de tokens (por ejemplo, para detectar intercambios) directamente desde la respuesta, sin llamadas posteriores.

## Filtros

Puedes usar operadores de comparación para `slot`, `blockTime` e `signature`, además de los filtros especiales `status`, `tokenAccounts` e `tokenTransfer`. Al combinar varios filtros, el resultado se restringe a su intersección.

### Operadores de comparación

Estos operadores funcionan como consultas de bases de datos para darte un control preciso sobre el intervalo de datos.

| Operador | Nombre completo   | Descripción                                            | Ejemplo                         |
| -------- | ----------------- | ------------------------------------------------------ | ------------------------------- |
| `gte`    | Mayor o igual que | Incluye valores ≥ al valor especificado                | `slot: { gte: 100 }`            |
| `gt`     | Mayor que         | Incluye valores > al valor especificado                | `blockTime: { gt: 1641081600 }` |
| `lte`    | Menor o igual que | Incluye valores ≤ al valor especificado                | `slot: { lte: 2000 }`           |
| `lt`     | Menor que         | Incluye valores \< al valor especificado               | `blockTime: { lt: 1641168000 }` |
| `eq`     | Igual             | Incluye valores exactamente iguales (solo `blockTime`) | `blockTime: { eq: 1641081600 }` |

### Filtros de enumeración

| Filtro          | Descripción                                                | Valores                          |
| --------------- | ---------------------------------------------------------- | -------------------------------- |
| `status`        | Filtra las transacciones según su éxito o fallo            | `succeeded`, `failed` o `any`    |
| `tokenAccounts` | Filtra las transacciones de cuentas de tokens relacionadas | `none`, `balanceChanged` o `all` |

Ejemplos de filtros combinados:

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

### Cuentas de tokens asociadas

En Solana, una billetera no almacena tokens directamente. En su lugar, la billetera posee cuentas de tokens, y esas cuentas almacenan los tokens. Cuando alguien te envía USDC, este se deposita en tu cuenta de tokens USDC, no en la dirección principal de tu billetera.

Este método es único porque puede consultar el **historial completo de tokens**, incluidas las cuentas de tokens asociadas (ATA) de una billetera. Los métodos RPC nativos, como `getSignaturesForAddress`, no incluyen las ATA.

El filtro `tokenAccounts` controla este comportamiento:

* **`none`** (predeterminado): solo devuelve las transacciones que hacen referencia directa a la dirección de la billetera. Úsalo si solo te interesan las interacciones directas de la billetera.
* **`balanceChanged`** (recomendado): devuelve las transacciones que hacen referencia a la dirección de la billetera o modifican el saldo de una cuenta de tokens propiedad de la billetera. Esto excluye el spam y operaciones no relacionadas, como el cobro de comisiones o las delegaciones, para ofrecerte una vista clara de la actividad relevante de la billetera.
* **`all`**: devuelve todas las transacciones que hacen referencia a la dirección de la billetera o a cualquier cuenta de tokens propiedad de esta.

El filtro `tokenAccounts` no admite transacciones anteriores a diciembre de 2022. Depende de los metadatos de transferencia de tokens incorporados a Solana en el slot 111,491,819. Para cubrir la actividad anterior, consulta la [solución alternativa para cuentas de tokens históricas](#limitaciones-y-casos-extremos).

### Filtro de transferencias de tokens

El filtro `tokenTransfer` restringe los resultados a las transacciones en las que la dirección consultada participó en una transferencia de tokens que coincide con criterios específicos: una contraparte, acuñación, dirección de transferencia o intervalo de importes determinados.

Úsalo para responder preguntas como:

* ¿Cuándo recibió esta billetera USDC de una contraparte específica?
* Muestra todas las transferencias salientes superiores a 1,000 tokens.
* ¿Cuándo interactuó esta billetera con esta acuñación específica?

El filtro es un campo opcional dentro del objeto `filters` de la configuración de la solicitud:

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

Todos los campos dentro de `tokenTransfer` son opcionales. La combinación de varios campos se trata como AND.

| Campo       | Tipo                         | Valor predeterminado | Descripción                                                                                                          |
| ----------- | ---------------------------- | -------------------- | -------------------------------------------------------------------------------------------------------------------- |
| `with`      | string (pubkey)              | -                    | Dirección de la contraparte. Coincide con transferencias cuyo otro extremo es esta dirección.                        |
| `direction` | `"in"` \| `"out"` \| `"any"` | `"any"`              | Indica si la dirección consultada recibió, envió o realizó cualquiera de las dos acciones.                           |
| `mint`      | string (pubkey)              | -                    | Acuñación del token por la que se filtrará.                                                                          |
| `amount`    | object                       | -                    | Comparación de importes. Usa el importe sin procesar en cadena, no el importe de la IU ni el ajustado por decimales. |

Operadores de intervalo de importes:

| Operador | Significado             |
| -------- | ----------------------- |
| `gt`     | Estrictamente mayor que |
| `gte`    | Mayor o igual que       |
| `lt`     | Estrictamente menor que |
| `lte`    | Menor o igual que       |

Puedes combinar operadores de importes, como `{ "gte": 1000000, "lte": 5000000 }` para un intervalo cerrado. `tokenTransfer` se combina con los demás filtros de nivel superior (`slot`, `blockTime`, `status` e `tokenAccounts`); el resultado final es la intersección.

## Ejemplos

### Análisis basados en tiempo

Genera informes mensuales de transacciones:

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

Procesa los datos para el análisis:

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

### Creación de acuñaciones de tokens

Busca la transacción de creación de la acuñación de un token específico:

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

Para la creación de un pool de liquidez, consulta la dirección del 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
    }
  ]
}
```

Esto permite encontrar el momento exacto en que se creó una acuñación de tokens o un pool de liquidez, incluida la dirección del creador y los parámetros iniciales.

### Transacciones de financiamiento

Averigua quién financió una dirección específica:

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

Después, analiza los datos de la transacción para encontrar transferencias de 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]}`);
    }
  });
});
```

Las primeras transacciones suelen revelar la fuente de financiamiento y pueden ayudar a identificar direcciones relacionadas o patrones de financiamiento.

### Transferencias de tokens

Filtra por `tokenTransfer` para aislar movimientos específicos de tokens.

Entradas de USDC a una dirección:

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

Transferencias salientes de gran valor a una contraparte específica:

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

Combinado con un intervalo de slots y un estado:

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

## Paginación

Cuando tengas más transacciones que el límite, usa el `paginationToken` de la respuesta para obtener la página siguiente. El token es una cadena simple con el formato `"slot:position"` que indica a la API desde dónde continuar.

Usa el token de paginación de cada respuesta para obtener la página siguiente:

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

### Varias direcciones

No puedes consultar varias direcciones en una sola solicitud. Cada consulta de dirección cuenta como una solicitud independiente a la API y se mide como tal. Para obtener transacciones de varias direcciones, consulta cada dirección dentro del mismo intervalo de tiempo o slots y, después, combina y ordena los resultados:

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

Para analizar historiales más extensos, recorre intervalos de tiempo o slots (por ejemplo, 1000 slots por vez) y repite este patrón.

## Prácticas recomendadas

**Rendimiento.** Usa `transactionDetails: "signatures"` cuando no necesites los datos completos de las transacciones. Usa tamaños de página razonables para mejorar los tiempos de respuesta y filtra por intervalos de tiempo o slots específicos para realizar consultas más focalizadas.

**Filtrado.** Comienza con filtros amplios y restrínge los resultados progresivamente. Usa filtros basados en tiempo para los flujos de análisis e informes, y combina varios filtros para crear consultas precisas dirigidas a tipos de transacciones o periodos específicos.

**Paginación.** Guarda los tokens de paginación cuando necesites reanudar consultas grandes más adelante. Supervisa la profundidad de paginación para planificar el rendimiento y usa el orden ascendente cuando necesites reproducir eventos históricos en orden cronológico.

**Manejo de errores.** Gestiona los límites de frecuencia con reintentos y espera exponencial. Valida las direcciones antes de realizar solicitudes y almacena en caché los resultados cuando corresponda para reducir el uso de la API.

## Limitaciones y casos extremos

Un pequeño conjunto de direcciones se redirige al archivo heredado, se limita a una alternativa de análisis por slots o devuelve resultados vacíos. La detección de cuentas de tokens antes del slot 111,491,819 también requiere una solución alternativa. Expande las secciones siguientes para consultar todos los detalles.

<Accordion title="Unsupported and specially-routed addresses">
  **Redirección al archivo antiguo.** Las solicitudes para estas direcciones se redirigen a nuestro sistema de archivo antiguo.

  | Dirección                                     | Nombre                                                                                                                |
  | --------------------------------------------- | --------------------------------------------------------------------------------------------------------------------- |
  | `Stake11111111111111111111111111111111111111` | [Programa de staking](https://orbmarkets.io/address/Stake11111111111111111111111111111111111111/history)              |
  | `StakeConfig11111111111111111111111111111111` | [Configuración de staking](https://orbmarkets.io/address/StakeConfig11111111111111111111111111111111/history)         |
  | `Sysvar1111111111111111111111111111111111111` | [Propietario Sysvar](https://orbmarkets.io/address/Sysvar1111111111111111111111111111111111111/history)               |
  | `AddressLookupTab1e1111111111111111111111111` | [Tabla de búsqueda de direcciones](https://orbmarkets.io/address/AddressLookupTab1e1111111111111111111111111/history) |
  | `BPFLoaderUpgradeab1e11111111111111111111111` | [BPF Loader actualizable](https://orbmarkets.io/address/BPFLoaderUpgradeab1e11111111111111111111111/history)          |

  **Alternativa de análisis por slots.** Las solicitudes para estas direcciones se reenvían a nuestro nuevo sistema de archivo y pueden consultarse mediante un análisis slot por slot (máximo de 100 slots). Sin embargo, estos datos no están indexados.

  | Dirección                                     | Nombre                                                                                                      |
  | --------------------------------------------- | ----------------------------------------------------------------------------------------------------------- |
  | `11111111111111111111111111111111`            | [Programa del sistema](https://orbmarkets.io/address/11111111111111111111111111111111/history)              |
  | `ComputeBudget111111111111111111111111111111` | [Presupuesto de cómputo](https://orbmarkets.io/address/ComputeBudget111111111111111111111111111111/history) |
  | `MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr` | [Programa Memo](https://orbmarkets.io/address/MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr/history)          |
  | `Vote111111111111111111111111111111111111111` | [Programa de votación](https://orbmarkets.io/address/Vote111111111111111111111111111111111111111/history)   |

  **Devuelve resultados vacíos (`is_reserved_address`).** Las solicitudes se reenvían a nuestro nuevo sistema de archivo; sin embargo, los datos no están indexados y las consultas devuelven resultados vacíos.

  | Dirección                                      | Nombre                                                                                                                   |
  | ---------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------ |
  | `BPFLoader1111111111111111111111111111111111`  | [BPF Loader (obsoleto)](https://orbmarkets.io/address/BPFLoader1111111111111111111111111111111111/history)               |
  | `BPFLoader2111111111111111111111111111111111`  | [BPF Loader](https://orbmarkets.io/address/BPFLoader2111111111111111111111111111111111/history)                          |
  | `Config1111111111111111111111111111111111111`  | [Programa de configuración](https://orbmarkets.io/address/Config1111111111111111111111111111111111111/history)           |
  | `Ed25519SigVerify111111111111111111111111111`  | [Programa Ed25519](https://orbmarkets.io/address/Ed25519SigVerify111111111111111111111111111/history)                    |
  | `Feature111111111111111111111111111111111111`  | [Programa de funciones](https://orbmarkets.io/address/Feature111111111111111111111111111111111111/history)               |
  | `KeccakSecp256k11111111111111111111111111111`  | [Programa Secp256k1](https://orbmarkets.io/address/KeccakSecp256k11111111111111111111111111111/history)                  |
  | `LoaderV411111111111111111111111111111111111`  | [Loader V4](https://orbmarkets.io/address/LoaderV411111111111111111111111111111111111/history)                           |
  | `NativeLoader1111111111111111111111111111111`  | [Loader nativo](https://orbmarkets.io/address/NativeLoader1111111111111111111111111111111/history)                       |
  | `SysvarC1ock11111111111111111111111111111111`  | [Sysvar del reloj](https://orbmarkets.io/address/SysvarC1ock11111111111111111111111111111111/history)                    |
  | `SysvarEpochSchedu1e111111111111111111111111`  | [Sysvar de programación de épocas](https://orbmarkets.io/address/SysvarEpochSchedu1e111111111111111111111111/history)    |
  | `SysvarFees111111111111111111111111111111111`  | [Sysvar de comisiones](https://orbmarkets.io/address/SysvarFees111111111111111111111111111111111/history)                |
  | `Sysvar1nstructions1111111111111111111111111`  | [Sysvar de instrucciones](https://orbmarkets.io/address/Sysvar1nstructions1111111111111111111111111/history)             |
  | `SysvarRecentB1ockHashes11111111111111111111`  | [Sysvar de blockhashes recientes](https://orbmarkets.io/address/SysvarRecentB1ockHashes11111111111111111111/history)     |
  | `SysvarRent111111111111111111111111111111111`  | [Sysvar de renta](https://orbmarkets.io/address/SysvarRent111111111111111111111111111111111/history)                     |
  | `SysvarRewards111111111111111111111111111111`  | [Sysvar de recompensas](https://orbmarkets.io/address/SysvarRewards111111111111111111111111111111/history)               |
  | `SysvarS1otHashes111111111111111111111111111`  | [Sysvar de hashes de slots](https://orbmarkets.io/address/SysvarS1otHashes111111111111111111111111111/history)           |
  | `SysvarS1otHistory11111111111111111111111111`  | [Sysvar del historial de slots](https://orbmarkets.io/address/SysvarS1otHistory11111111111111111111111111/history)       |
  | `SysvarStakeHistory1111111111111111111111111`  | [Sysvar del historial de staking](https://orbmarkets.io/address/SysvarStakeHistory1111111111111111111111111/history)     |
  | `SysvarEpochRewards11111111111111111111111111` | [Sysvar de recompensas de época](https://orbmarkets.io/address/SysvarEpochRewards11111111111111111111111111/history)     |
  | `SysvarLastRestartS1ot1111111111111111111111`  | [Sysvar del slot del último reinicio](https://orbmarkets.io/address/SysvarLastRestartS1ot1111111111111111111111/history) |
</Accordion>

<Accordion title="Workaround: historical token account discovery (before slot 111,491,819)">
  Para las direcciones con actividad de cuentas de tokens anterior al slot 111,491,819, el filtro `tokenAccounts` no puede determinar la propiedad porque el campo `owner` aún no existía en los metadatos de saldos de tokens. Para obtener resultados completos, puedes detectar manualmente esas cuentas de tokens mediante el análisis de las instrucciones de transacciones antiguas y, después, consultar `getTransactionsForAddress` en paralelo para cada una.

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

## ¿En qué se diferencia de getSignaturesForAddress?

Si conoces el método estándar `getSignaturesForAddress`, `getTransactionsForAddress` reúne flujos de trabajo de varios pasos en una sola llamada y agrega filtrado, ordenamiento y compatibilidad con cuentas de tokens. Para convertir código existente paso a paso, consulta la [guía de migración](/docs/es/rpc/migrate-to-gettransactionsforaddress).

### Obtén transacciones completas en una sola llamada

Con `getSignaturesForAddress`, necesitas dos pasos:

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

Con `getTransactionsForAddress`, solo necesitas una llamada:

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

### Obtén el historial de tokens en una sola llamada

Con `getSignaturesForAddress`, primero debes llamar a `getTokenAccountsByOwner` y, después, consultar cada cuenta de tokens:

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

Con `getTransactionsForAddress`, solo necesitas establecer `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;
```

### Funciones adicionales

<CardGroup cols={2}>
  <Card title="Chronological sorting" icon="arrow-up">
    Ordena las transacciones de la más antigua a la más reciente con `sortOrder: 'asc'`.
  </Card>

  <Card title="Time-based filtering" icon="clock">
    Filtra por intervalos de tiempo mediante filtros `blockTime`.
  </Card>

  <Card title="Status filtering" icon="filter">
    Obtén solo transacciones exitosas o fallidas con el filtro `status`.
  </Card>

  <Card title="Simpler pagination" icon="list">
    Usa `paginationToken` en lugar de las confusas firmas `before`/`until`.
  </Card>
</CardGroup>

## Próximos pasos

<CardGroup cols={2}>
  <Card title="Indexing guide" icon="layer-group" href="/docs/es/rpc/how-to-index-solana-data">
    Usa getTransactionsForAddress para rellenar datos históricos y sincronizar un índice de Solana.
  </Card>

  <Card title="getTransfersByAddress" icon="arrow-right-arrow-left" href="/docs/es/rpc/gettransfersbyaddress">
    Historial analizado que solo incluye transferencias para pagos y conciliación.
  </Card>

  <Card title="API reference" icon="code" href="/docs/es/api-reference/rpc/http/gettransactionsforaddress">
    Esquema completo de solicitud y respuesta de getTransactionsForAddress.
  </Card>

  <Card title="Historical data overview" icon="clock-rotate-left" href="/docs/es/rpc/historical-data">
    Compara todos los métodos de datos históricos de Solana.
  </Card>
</CardGroup>