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

# Historial de transacciones

> Obtén el historial de transacciones legible de cualquier dirección de Solana con filtros, rangos de tiempo y slots, y paginación.

<Warning>
  La API de transacciones mejoradas es un producto heredado en modo de mantenimiento. Sigue funcionando y estas páginas continúan disponibles, pero ya no recibe nuevos tipos de analizadores ni nuevas funcionalidades. Su sucesor es [Eventos analizados](/docs/es/parsed-events), que decodifica instrucciones mediante el catálogo de IDL y está en beta abierta para los planes de pago. La [guía de migración](/docs/es/parsed-events/guides/migrate-from-enhanced-transactions) explica el proceso paso a paso. También puedes usar [`getTransactionsForAddress`](/docs/es/rpc/gettransactionsforaddress) para consultar el historial de transacciones y completar datos históricos, y la [Wallet API](/docs/es/wallet-api/overview) para obtener datos de billeteras legibles.
</Warning>

## Descripción general

El endpoint de historial de transacciones devuelve el historial de transacciones legible de cualquier dirección de Solana. En lugar de trabajar con datos de instrucciones sin procesar y listas de cuentas, obtienes información estructurada sobre:

* Qué ocurrió en la transacción (transferencias, intercambios y actividades con NFT).
* Qué cuentas participaron.
* Cuánto SOL o cuántos tokens se transfirieron.
* Metadatos asociados (direcciones de acuñación de tokens, nombres de tokens, símbolos de tokens y más).

Envía una solicitud `GET` a `/v0/addresses/{address}/transactions`. Internamente, este endpoint utiliza el método RPC [`getTransactionsForAddress`](/docs/es/rpc/gettransactionsforaddress).

## Cuándo usarlo

* Muestras a los usuarios el historial de transacciones de una dirección (billeteras, rastreadores de portafolios o exploradores).
* Quieres un historial preanalizado y legible sin escribir tu propio decodificador.
* Necesitas filtrar el historial por tipo de transacción, rango de tiempo o rango de slots.
* Necesitas el historial completo de tokens de una billetera, incluidas las cuentas de tokens asociadas (ATA); consulta la sección siguiente.

Para desarrollos nuevos, [`getTransactionsForAddress`](/docs/es/rpc/gettransactionsforaddress) es la opción moderna y nativa de Helius, con filtrado del lado del servidor y búsquedas de cuentas de tokens.

## Inicio rápido

<Steps>
  <Step title="Get your API key">
    Regístrate en [dashboard.helius.dev](https://dashboard.helius.dev) y copia tu clave de API.
  </Step>

  <Step title="GET the address transactions endpoint">
    Obtén el historial de transacciones de cualquier dirección de Solana.

    <Tabs>
      <Tab title="JavaScript">
        ```javascript theme={"system"}
        const fetchWalletTransactions = async () => {
          const walletAddress = "M2mx93ekt1fmXSVkTrUL9xVFHkmME8HTUi5Cyc5aF7K"; // Replace with target wallet
          const url = `https://mainnet.helius-rpc.com/v0/addresses/${walletAddress}/transactions?api-key=YOUR_API_KEY`;

          const response = await fetch(url);
          const transactions = await response.json();
          console.log("Wallet transactions:", transactions);
        };

        fetchWalletTransactions();
        ```
      </Tab>

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

        def fetch_wallet_transactions():
            wallet_address = "M2mx93ekt1fmXSVkTrUL9xVFHkmME8HTUi5Cyc5aF7K"  # Replace with target wallet
            url = f"https://mainnet.helius-rpc.com/v0/addresses/{wallet_address}/transactions?api-key=YOUR_API_KEY"

            response = requests.get(url)
            transactions = response.json()
            print("Wallet transactions:", transactions)

        fetch_wallet_transactions()
        ```
      </Tab>
    </Tabs>
  </Step>

  <Step title="Filter and paginate">
    Limita los resultados con los filtros `type`, de tiempo y de slots que aparecen a continuación. Luego, recorre por páginas las direcciones de gran volumen mediante cursores de firmas.
  </Step>
</Steps>

## Compatibilidad con redes

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

## Parámetros de la solicitud

| Parámetro          | Descripción                                                                 | Valor predeterminado | Ejemplo                          |
| ------------------ | --------------------------------------------------------------------------- | -------------------- | -------------------------------- |
| `limit`            | Número de transacciones que se devolverán (1-100)                           | 10                   | `&limit=25`                      |
| `before-signature` | Obtiene transacciones anteriores a esta firma (úsalo con `sort-order=desc`) | -                    | `&before-signature=sig123...`    |
| `after-signature`  | Obtiene transacciones posteriores a esta firma (úsalo con `sort-order=asc`) | -                    | `&after-signature=sig456...`     |
| `type`             | Filtra por tipo de transacción                                              | -                    | `&type=NFT_SALE`                 |
| `sort-order`       | Orden de los resultados                                                     | `desc`               | `&sort-order=asc`                |
| `token-accounts`   | Filtra transacciones de cuentas de tokens relacionadas                      | `none`               | `&token-accounts=balanceChanged` |
| `commitment`       | Nivel de compromiso                                                         | `finalized`          | `&commitment=confirmed`          |

### Filtrado por tiempo

| Parámetro  | Descripción                                              | Ejemplo                |
| ---------- | -------------------------------------------------------- | ---------------------- |
| `gt-time`  | Transacciones posteriores a esta marca de tiempo Unix    | `&gt-time=1656442333`  |
| `gte-time` | Transacciones en esta marca de tiempo Unix o posteriores | `&gte-time=1656442333` |
| `lt-time`  | Transacciones anteriores a esta marca de tiempo Unix     | `&lt-time=1656442333`  |
| `lte-time` | Transacciones en esta marca de tiempo Unix o anteriores  | `&lte-time=1656442333` |

### Filtrado por slots

| Parámetro  | Descripción                              | Ejemplo               |
| ---------- | ---------------------------------------- | --------------------- |
| `gt-slot`  | Transacciones posteriores a este slot    | `&gt-slot=148277128`  |
| `gte-slot` | Transacciones en este slot o posteriores | `&gte-slot=148277128` |
| `lt-slot`  | Transacciones anteriores a este slot     | `&lt-slot=148277128`  |
| `lte-slot` | Transacciones en este slot o anteriores  | `&lte-slot=148277128` |

Notas sobre el filtrado:

* Los parámetros de tiempo usan marcas de tiempo Unix (segundos desde el inicio de la época); los parámetros de slots usan números de slot de Solana.
* No puedes combinar filtros de tiempo y de slots en la misma solicitud.
* Usa `sort-order=asc` para el orden ascendente (las más antiguas primero) o `sort-order=desc` para el orden descendente (las más recientes primero).
* Usa filtros de tiempo o de slots para reducir el espacio de búsqueda cuando conozcas el periodo aproximado. Combínalos con `limit` para controlar el tamaño de la página.

## 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, los fondos llegan a tu cuenta de tokens USDC en lugar de a la dirección principal de tu billetera.

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

El filtro `token-accounts` controla este comportamiento:

* **`none`** (valor predeterminado): solo devuelve transacciones que hacen referencia directa a la dirección de la billetera. Úsalo si solo te interesan las interacciones directas con la billetera.
* **`balanceChanged`** (recomendado): devuelve 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 las 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 la billetera.

<Warning>
  El filtro `token-accounts` depende del campo `owner` de los metadatos de saldo de tokens, que no estaba disponible antes del slot 111,491,819 (aproximadamente diciembre de 2022). Las transacciones que involucren cuentas de tokens activas antes de este slot pueden faltar en los resultados de `balanceChanged` e `all`. Consulta el [tutorial de getTransactionsForAddress](/docs/es/rpc/gettransactionsforaddress#limitaciones-y-casos-extremos) para ver una solución alternativa con un ejemplo de código completo.
</Warning>

## Filtros

### Filtrar por tipo de transacción

Obtén solo tipos específicos de transacciones, como ventas de NFT, transferencias de tokens o intercambios:

<Tabs>
  <Tab title="NFT Sales">
    ```javascript theme={"system"}
    const fetchNftSales = async () => {
      const tokenAddress = "GjUG1BATg5V4bdAr1csKys1XK9fmrbntgb1iV7rAkn94"; // NFT mint address
      const url = `https://mainnet.helius-rpc.com/v0/addresses/${tokenAddress}/transactions?api-key=YOUR_API_KEY&type=NFT_SALE`;

      const response = await fetch(url);
      const nftSales = await response.json();
      console.log("NFT sale transactions:", nftSales);
    };
    ```
  </Tab>

  <Tab title="Token Transfers">
    ```javascript theme={"system"}
    const fetchTokenTransfers = async () => {
      const walletAddress = "M2mx93ekt1fmXSVkTrUL9xVFHkmME8HTUi5Cyc5aF7K"; // Wallet address
      const url = `https://mainnet.helius-rpc.com/v0/addresses/${walletAddress}/transactions?api-key=YOUR_API_KEY&type=TRANSFER`;

      const response = await fetch(url);
      const transfers = await response.json();
      console.log("Transfer transactions:", transfers);
    };
    ```
  </Tab>

  <Tab title="Swaps">
    ```javascript theme={"system"}
    const fetchSwapTransactions = async () => {
      const walletAddress = "M2mx93ekt1fmXSVkTrUL9xVFHkmME8HTUi5Cyc5aF7K"; // Wallet address
      const url = `https://mainnet.helius-rpc.com/v0/addresses/${walletAddress}/transactions?api-key=YOUR_API_KEY&type=SWAP`;

      const response = await fetch(url);
      const swaps = await response.json();
      console.log("Swap transactions:", swaps);
    };
    ```
  </Tab>
</Tabs>

Para ver la lista completa de tipos de transacciones compatibles, consulta la [referencia de la API de historial de transacciones](/docs/es/api-reference/enhanced-transactions/gettransactionsbyaddress).

### Filtrado de tipos en tiempo de ejecución

<Note>
  El filtrado por tipo se realiza en tiempo de ejecución: la API busca transacciones de forma secuencial hasta encontrar al menos 50 elementos coincidentes. Si no encuentra ninguna coincidencia dentro de la ventana de búsqueda, devuelve un error con una firma para continuar la búsqueda. Este es el comportamiento esperado, no un fallo.
</Note>

Cuando no se encuentran transacciones coincidentes dentro de la ventana de búsqueda actual, la API devuelve una respuesta de error como esta:

```json theme={"system"}
{
  "error": "Failed to find events within the search period. To continue search, query the API again with the `before-signature` parameter set to 2UKbsu95YzxGjUGYRg2znozmmVADVgmnhHqzDxq8Xfb3V5bf2NHUkaXGPrUpQnRFVHVKbawdQXtm4xJt9njMDHvg."
}
```

Para continuar, usa la firma del mensaje de error con el parámetro correspondiente (`before-signature` para el orden descendente o `after-signature` para el ascendente) en tu siguiente solicitud.

<Accordion title="Continuation loop for type filters (full example)">
  ```javascript theme={"system"}
  const fetchFilteredTransactions = async (sortOrder = 'desc') => {
    const walletAddress = "M2mx93ekt1fmXSVkTrUL9xVFHkmME8HTUi5Cyc5aF7K";
    const transactionType = "NFT_SALE";
    let continuationSignature = null;
    let allFilteredTransactions = [];
    let maxRetries = 10; // Prevent infinite loops
    let retryCount = 0;

    // Determine which parameter to use based on sort order
    const continuationParam = sortOrder === 'asc' ? 'after-signature' : 'before-signature';

    while (retryCount < maxRetries) {
      // Build URL with optional continuation parameter
      let url = `https://mainnet.helius-rpc.com/v0/addresses/${walletAddress}/transactions?api-key=YOUR_API_KEY&type=${transactionType}&sort-order=${sortOrder}`;

      if (continuationSignature) {
        url += `&${continuationParam}=${continuationSignature}`;
      }

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

        // Check if we received an error about search period
        if (data.error && data.error.includes("Failed to find events within the search period")) {
          // Extract the signature from the error message
          const signatureMatch = data.error.match(/parameter set to ([A-Za-z0-9]+)/);

          if (signatureMatch && signatureMatch[1]) {
            console.log(`No results in this period. Continuing search from: ${signatureMatch[1]}`);
            continuationSignature = signatureMatch[1];
            retryCount++;
            continue; // Continue searching with new signature
          } else {
            console.log("No more transactions to search");
            break;
          }
        }

        // Check if we received transactions
        if (Array.isArray(data) && data.length > 0) {
          console.log(`Found ${data.length} ${transactionType} transactions`);
          allFilteredTransactions = [...allFilteredTransactions, ...data];

          // Set continuation signature for next page
          continuationSignature = data[data.length - 1].signature;
          retryCount = 0; // Reset retry count since we found results
        } else {
          console.log("No more transactions found");
          break;
        }

      } catch (error) {
        console.error("Error fetching transactions:", error);
        break;
      }
    }

    console.log(`Total ${transactionType} transactions found: ${allFilteredTransactions.length}`);
    return allFilteredTransactions;
  };

  // Usage examples:
  // Descending order (newest first) - uses 'before-signature' parameter
  fetchFilteredTransactions('desc');

  // Ascending order (oldest first) - uses 'after-signature' parameter
  fetchFilteredTransactions('asc');
  ```

  Puntos clave:

  * La API busca en un máximo de 50 transacciones a la vez cuando usas filtros de tipo.
  * Si no se encuentra ninguna coincidencia, usa la firma del mensaje de error para continuar la búsqueda.
  * Usa `before-signature` cuando busques en orden descendente (valor predeterminado, las más recientes primero).
  * Usa `after-signature` cuando busques en orden ascendente (las más antiguas primero); es obligatorio para las búsquedas cronológicas.
  * Implementa un límite máximo de reintentos para evitar bucles infinitos.
</Accordion>

## Ejemplos

Los siguientes escenarios abarcan rangos de tiempo y de slots, ordenamiento, ATA y filtros combinados.

<Accordion title="Filter by time range">
  Obtén transacciones dentro de un periodo específico:

  <Tabs>
    <Tab title="Last 24 Hours">
      ```javascript theme={"system"}
      const fetchRecentTransactions = async () => {
        const walletAddress = "M2mx93ekt1fmXSVkTrUL9xVFHkmME8HTUi5Cyc5aF7K";
        const now = Math.floor(Date.now() / 1000);
        const oneDayAgo = now - (24 * 60 * 60);

        const url = `https://mainnet.helius-rpc.com/v0/addresses/${walletAddress}/transactions?api-key=YOUR_API_KEY&gte-time=${oneDayAgo}&lte-time=${now}`;

        const response = await fetch(url);
        const transactions = await response.json();
        console.log("Transactions from last 24 hours:", transactions);
      };
      ```
    </Tab>

    <Tab title="Specific Date Range">
      ```javascript theme={"system"}
      const fetchTransactionsByDateRange = async () => {
        const walletAddress = "M2mx93ekt1fmXSVkTrUL9xVFHkmME8HTUi5Cyc5aF7K";

        // January 1, 2024 to January 31, 2024
        const startTime = Math.floor(new Date('2024-01-01').getTime() / 1000);
        const endTime = Math.floor(new Date('2024-01-31').getTime() / 1000);

        const url = `https://mainnet.helius-rpc.com/v0/addresses/${walletAddress}/transactions?api-key=YOUR_API_KEY&gte-time=${startTime}&lte-time=${endTime}`;

        const response = await fetch(url);
        const transactions = await response.json();
        console.log("Transactions in January 2024:", transactions);
      };
      ```
    </Tab>
  </Tabs>
</Accordion>

<Accordion title="Filter by slot range">
  Obtén transacciones dentro de un rango de slots específico:

  ```javascript theme={"system"}
  const fetchTransactionsBySlotRange = async () => {
    const walletAddress = "M2mx93ekt1fmXSVkTrUL9xVFHkmME8HTUi5Cyc5aF7K";
    const startSlot = 148000000;
    const endSlot = 148100000;

    const url = `https://mainnet.helius-rpc.com/v0/addresses/${walletAddress}/transactions?api-key=YOUR_API_KEY&gte-slot=${startSlot}&lte-slot=${endSlot}`;

    const response = await fetch(url);
    const transactions = await response.json();
    console.log(`Transactions between slots ${startSlot} and ${endSlot}:`, transactions);
  };
  ```
</Accordion>

<Accordion title="Change sort order">
  Obtén transacciones en orden ascendente (las más antiguas primero):

  ```javascript theme={"system"}
  const fetchOldestTransactions = async () => {
    const walletAddress = "M2mx93ekt1fmXSVkTrUL9xVFHkmME8HTUi5Cyc5aF7K";
    const url = `https://mainnet.helius-rpc.com/v0/addresses/${walletAddress}/transactions?api-key=YOUR_API_KEY&sort-order=asc&limit=10`;

    const response = await fetch(url);
    const transactions = await response.json();
    console.log("10 oldest transactions:", transactions);
  };
  ```
</Accordion>

<Accordion title="Include transfers for related token accounts">
  Consulta el historial completo de una billetera, incluidas las direcciones de tokens asociadas (ATA):

  ```javascript theme={"system"}
  const fetchTransactionsWithATA = async () => {
    const walletAddress = "M2mx93ekt1fmXSVkTrUL9xVFHkmME8HTUi5Cyc5aF7K";

    const url = `https://mainnet.helius-rpc.com/v0/addresses/${walletAddress}/transactions?api-key=YOUR_API_KEY&token-accounts=balanceChanged&sort-order=desc&limit=50`;

    const response = await fetch(url);
    const transactions = await response.json();
    console.log("Most recent transactions (including ATA transfers)", transactions);
  };
  ```
</Accordion>

<Accordion title="Combine multiple filters">
  Combina el filtrado por tipo con un rango de tiempo y un orden personalizado:

  ```javascript theme={"system"}
  const fetchFilteredTransactionsAdvanced = async () => {
    const walletAddress = "M2mx93ekt1fmXSVkTrUL9xVFHkmME8HTUi5Cyc5aF7K";

    // Get NFT sales from the last 7 days, oldest first
    const now = Math.floor(Date.now() / 1000);
    const sevenDaysAgo = now - (7 * 24 * 60 * 60);

    const url = `https://mainnet.helius-rpc.com/v0/addresses/${walletAddress}/transactions?api-key=YOUR_API_KEY&type=NFT_SALE&gte-time=${sevenDaysAgo}&sort-order=asc&limit=50`;

    const response = await fetch(url);
    const transactions = await response.json();
    console.log("NFT sales from last 7 days (oldest first):", transactions);
  };
  ```
</Accordion>

## Paginación

Para las direcciones de gran volumen, recorre los resultados por páginas usando como cursor la última firma de cada lote:

```javascript theme={"system"}
const fetchAllTransactions = async () => {
  const walletAddress = "2k5AXX4guW9XwRQ1AKCpAuUqgWDpQpwFfpVFh3hnm2Ha"; // Replace with target wallet
  const baseUrl = `https://mainnet.helius-rpc.com/v0/addresses/${walletAddress}/transactions?api-key=YOUR_API_KEY`;
  let url = baseUrl;
  let lastSignature = null;
  let allTransactions = [];

  while (true) {
    if (lastSignature) {
      url = baseUrl + `&before-signature=${lastSignature}`;
    }

    const response = await fetch(url);

    // Check response status
    if (!response.ok) {
      console.error(`API error: ${response.status}`);
      break;
    }

    const transactions = await response.json();

    if (transactions && transactions.length > 0) {
      console.log(`Fetched batch of ${transactions.length} transactions`);
      allTransactions = [...allTransactions, ...transactions];
      lastSignature = transactions[transactions.length - 1].signature;
    } else {
      console.log(`Finished! Total transactions: ${allTransactions.length}`);
      break;
    }
  }

  return allTransactions;
};
```

Para paginar dentro de un rango de tiempo, conserva los filtros de tiempo en cada solicitud y avanza el cursor `before-signature` en cada iteración:

```javascript theme={"system"}
const fetchAllTransactionsInTimeRange = async () => {
  const walletAddress = "M2mx93ekt1fmXSVkTrUL9xVFHkmME8HTUi5Cyc5aF7K";
  const startTime = Math.floor(new Date('2024-01-01').getTime() / 1000);
  const endTime = Math.floor(new Date('2024-01-31').getTime() / 1000);

  let beforeSignature = null;
  let allTransactions = [];

  while (true) {
    let url = `https://mainnet.helius-rpc.com/v0/addresses/${walletAddress}/transactions?api-key=YOUR_API_KEY&gte-time=${startTime}&lte-time=${endTime}&limit=100`;

    if (beforeSignature) {
      url += `&before-signature=${beforeSignature}`;
    }

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

    if (!Array.isArray(transactions) || transactions.length === 0) {
      break;
    }

    allTransactions = [...allTransactions, ...transactions];
    beforeSignature = transactions[transactions.length - 1].signature;

    console.log(`Fetched ${transactions.length} transactions, total: ${allTransactions.length}`);
  }

  console.log(`Total transactions in time range: ${allTransactions.length}`);
  return allTransactions;
};
```

## Próximos pasos

<CardGroup cols={2}>
  <Card title="getTransactionsForAddress" icon="clock-rotate-left" href="/docs/es/rpc/gettransactionsforaddress">
    El reemplazo moderno y nativo de Helius para consultar el historial de transacciones y completar datos históricos.
  </Card>

  <Card title="Wallet API" icon="wallet" href="/docs/es/wallet-api/overview">
    Endpoints REST para obtener datos de billeteras legibles: saldos, historial y transferencias.
  </Card>

  <Card title="Parse Transactions" icon="code" href="/docs/es/enhanced-transactions/parse-transactions">
    Analiza una o más firmas de transacciones y conviértelas en datos legibles.
  </Card>

  <Card title="Getting Data overview" icon="database" href="/docs/es/getting-data">
    Compara todas las opciones de Helius para consultar datos de Solana.
  </Card>
</CardGroup>