> ## 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. # Migra de getSignaturesForAddress + getTransaction a getTransactionsForAddress > Reemplaza el bucle de getSignaturesForAddress + getTransaction con una sola llamada a getTransactionsForAddress: asignación de parámetros, código anterior y posterior, y paginación. ## ¿Por qué migrar? La forma estándar de obtener el historial de transacciones de una dirección en Solana requiere dos pasos: llamar a `getSignaturesForAddress` para enumerar las firmas y, luego, llamar a `getTransaction` una vez por cada firma para obtener los detalles. Para 1,000 transacciones, eso equivale a 1,001 solicitudes HTTP. [`getTransactionsForAddress`](/docs/es/rpc/gettransactionsforaddress) es un método RPC exclusivo de Helius que combina ambos pasos en una sola llamada. Devuelve hasta 1,000 transacciones completas por solicitud, con filtrado, ordenamiento bidireccional y compatibilidad con cuentas de tokens que los métodos estándar no ofrecen. | | `getSignaturesForAddress` + `getTransaction` | `getTransactionsForAddress` | | ---------------------------------------------- | -------------------------------------------- | -------------------------------------------- | | Solicitudes para 1,000 transacciones | 1,001 | 1 | | Créditos para 1,000 transacciones completas | \~1,001 (1 crédito por llamada) | 100 (10 créditos por cada 100 transacciones) | | Historial de cuentas de tokens asociadas (ATA) | No incluido | Incluido mediante `filters.tokenAccounts` | | Filtros de intervalo de tiempo y slot | No | Sí | | Filtro de estado (exitosas/fallidas) | No | Sí | | Orden de clasificación | Solo de más reciente a más antigua | De más reciente a más antigua o viceversa | | Paginación | Firmas `before`/`until` | `paginationToken` | El resultado: aproximadamente 10 veces menos créditos, 1,000 veces menos viajes de ida y vuelta, y sin procesamiento por lotes del lado del cliente, manejo de límites de frecuencia ni lógica de reintentos para la expansión de llamadas a `getTransaction`. ## Antes y después Esta es la misma tarea —obtener las últimas 1,000 transacciones de una dirección con todos sus detalles— con ambos patrones: ```javascript Before (two methods) theme={"system"} const rpcUrl = 'https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY'; // Step 1: Get signatures (1 request) const sigResponse = await fetch(rpcUrl, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'getSignaturesForAddress', params: ['YOUR_ADDRESS_HERE', { limit: 1000 }] }) }); const { result: signatures } = await sigResponse.json(); // Step 2: Get transaction details (1,000 additional requests) const transactions = await Promise.all( signatures.map(async (sig) => { const txResponse = await fetch(rpcUrl, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'getTransaction', params: [sig.signature, { maxSupportedTransactionVersion: 1 }] }) }); const { result } = await txResponse.json(); return result; }) ); ``` ```javascript After (one method) theme={"system"} const response = await fetch('https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'getTransactionsForAddress', params: [ 'YOUR_ADDRESS_HERE', { transactionDetails: 'full', maxSupportedTransactionVersion: 1, limit: 1000 } ] }) }); const { result } = await response.json(); const transactions = result.data; // Full transactions, same shape as getTransaction ``` `getTransactionsForAddress` no forma parte del RPC estándar de Solana, por lo que `@solana/web3.js` no tiene un método auxiliar `Connection` para él. Llámalo con una solicitud JSON-RPC directa, como se muestra arriba. Funciona en el mismo endpoint de Helius que el resto de tu tráfico RPC. ## Asignación de parámetros Cada opción del flujo anterior de dos pasos tiene un equivalente directo. La mayoría de los nombres se mantienen sin cambios; solo la paginación funciona de forma diferente. ### Desde getSignaturesForAddress | Opción anterior | Nuevo equivalente | | ---------------- | --------------------------------------------------------------------------- | | `limit` | `limit` — el mismo máximo de 1,000 | | `before` | `paginationToken` de la respuesta anterior | | `until` | `filters.signature.gt` | | `commitment` | `commitment` — solo `confirmed` o `finalized`; `processed` no es compatible | | `minContextSlot` | `minContextSlot` — sin cambios | ### Desde getTransaction | Opción anterior | Nuevo equivalente | | -------------------------------- | -------------------------------------------------------------- | | `encoding` | `encoding` — se aplica cuando `transactionDetails` es `"full"` | | `maxSupportedTransactionVersion` | `maxSupportedTransactionVersion` — sin cambios | | `commitment` | `commitment` — la misma regla indicada arriba | Dos funcionalidades no tienen ningún equivalente anterior: * `filters` — limita los resultados por `blockTime`, `slot`, `status`, `tokenTransfer` o `tokenAccounts` del lado del servidor, en lugar de obtener todo y filtrarlo en tu código. * `sortOrder: "asc"` — resultados cronológicos (primero los más antiguos), que los métodos estándar no pueden devolver sin obtener todo el historial e invertirlo. ## Pasos de migración `getTransactionsForAddress` es exclusivo de Helius. Funciona en `https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY` (y en devnet), el mismo endpoint que ya usan tus llamadas existentes si eres cliente de Helius. No necesitas cambiar la clave de API ni el plan. Elimina la llamada a `getSignaturesForAddress` y el bucle de `getTransaction`. Realiza una sola solicitud a `getTransactionsForAddress` con `transactionDetails: "full"` y conserva tus valores de `encoding`, `maxSupportedTransactionVersion` y `commitment` como se muestra en la [asignación de parámetros](#asignación-de-parámetros). Si solo necesitas las firmas (por ejemplo, para alimentar un pipeline existente), usa `transactionDetails: "signatures"` en su lugar. Tiene un costo fijo de 10 créditos por llamada. La envoltura de la respuesta cambia de tres formas: * Los resultados se encuentran en `result.data` (un arreglo), no directamente en `result`. * Cada entrada del modo completo es `{ slot, transactionIndex, blockTime, transaction, meta }`. Los objetos `transaction` e `meta` tienen una estructura idéntica a la que devuelve `getTransaction`, por lo que puedes conservar tu código de análisis sin cambios. * Las entradas del modo de firmas coinciden con la salida de `getSignaturesForAddress` (`signature`, `slot`, `err`, `memo`, `blockTime`, `confirmationStatus`), más un nuevo campo `transactionIndex`. Ten en cuenta una diferencia de comportamiento: con el patrón anterior, una llamada a `getTransaction` podía devolver `null` para una firma. Con `getTransactionsForAddress`, cada entrada de `result.data` es una transacción completa. Elimina cualquier manejo de valores nulos para detalles faltantes. Sustituye el bucle del cursor `before` por `paginationToken`: ```javascript theme={"system"} let paginationToken = null; const allTransactions = []; do { 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', maxSupportedTransactionVersion: 1, limit: 1000, ...(paginationToken && { paginationToken }) } ] }) }); const { result } = await response.json(); allTransactions.push(...result.data); paginationToken = result.paginationToken; } while (paginationToken); ``` El bucle termina cuando `paginationToken` es `null`. Ya no necesitas comparar listas de firmas ni llevar el seguimiento de la última firma por tu cuenta. Si usabas `until` para detenerte en una firma conocida, reemplázalo con `filters.signature: { gt: "KNOWN_SIGNATURE" }`. Si lo usabas para detenerte en un momento determinado, `filters.blockTime` o `filters.slot` suele ser una opción más adecuada. El patrón anterior omite por completo la actividad de las cuentas de tokens asociadas (ATA), a menos que también llames a `getTokenAccountsByOwner` y obtengas las firmas de cada cuenta de tokens. Para incluirla, agrega un filtro: ```json theme={"system"} { "filters": { "tokenAccounts": "balanceChanged" } } ``` `balanceChanged` devuelve transacciones que hacen referencia a la billetera o cambian el saldo de cualquier cuenta de tokens que le pertenezca, y excluye el spam. Consulta [cuentas de tokens asociadas](/docs/es/rpc/gettransactionsforaddress#cuentas-de-tokens-asociadas) para conocer las opciones `none`/`balanceChanged`/`all` y la salvedad para datos anteriores a 2022. Para una dirección de ejemplo, obtén el historial de ambas formas y compara los conjuntos de firmas. Si `filters.tokenAccounts` no está configurado (el valor predeterminado `none`), `getTransactionsForAddress` devuelve las mismas transacciones que `getSignaturesForAddress` para el mismo intervalo. Luego, implementa los cambios y elimina la ruta de código anterior. ## Diferencias de comportamiento que debes revisar La mayoría de las migraciones son reemplazos directos, pero revisa lo siguiente antes de publicar: * **Commitment.** `processed` no es compatible; usa `confirmed` o `finalized`. Si tu código anterior consultaba periódicamente el historial reciente con `processed`, cambia a `confirmed`. * **Medición.** Las respuestas de transacciones completas cuestan 10 créditos por cada 100 transacciones devueltas (con un mínimo de 10 créditos); las respuestas que solo contienen firmas tienen un costo fijo de 10 créditos. El patrón anterior costaba 1 crédito por llamada: era más barato por solicitud, pero mucho más caro por transacción obtenida. Las respuestas fallidas son gratuitas. Consulta [medición](/docs/es/rpc/gettransactionsforaddress#medición). * **Compatibilidad de red.** Mainnet tiene retención ilimitada. Devnet es compatible y ofrece 2 semanas de retención. Testnet no es compatible. * **Direcciones reservadas.** Un conjunto pequeño de direcciones del sistema (Vote Program, System Program y sysvars) se dirige a rutas de archivo alternativas o devuelve resultados vacíos. Si las indexas, revisa [limitaciones y casos extremos](/docs/es/rpc/gettransactionsforaddress#limitaciones-y-casos-extremos). * **Varias direcciones.** Al igual que en el flujo anterior, una solicitud cubre una dirección. Consulta las direcciones en paralelo y combina los resultados; consulta [varias direcciones](/docs/es/rpc/gettransactionsforaddress#varias-direcciones). ## Preguntas frecuentes ### ¿Es getTransactionsForAddress un método RPC estándar de Solana? No. Es un método exclusivo de Helius disponible en los endpoints RPC de Helius. El RPC estándar de Solana y otros proveedores solo ofrecen `getSignaturesForAddress` e `getTransaction`. Tus demás llamadas RPC no se ven afectadas: el método está disponible en el mismo endpoint junto con toda la superficie RPC estándar. ### ¿Todavía necesito getTransaction después de migrar? Solo para consultas individuales en las que ya tienes una firma y no tienes el contexto de una dirección, como verificar una transacción específica que pegó un usuario. Para cualquier historial basado en direcciones —procesos de backfill, indexación o feeds de actividad de billeteras—, `getTransactionsForAddress` reemplaza ambos métodos. ### ¿Funciona con @solana/web3.js? El método no está en la clase `Connection`, pero funciona con cualquier cliente HTTP que se conecte a tu URL RPC de Helius. Usa `fetch` (o el equivalente de tu lenguaje) con un cuerpo JSON-RPC estándar, como se muestra en los ejemplos anteriores. Puedes seguir usando `Connection` para todo lo demás. ### ¿Devolverá las mismas transacciones que getSignaturesForAddress? Sí. Con la configuración predeterminada (`filters.tokenAccounts: "none"`), devuelve las transacciones que hacen referencia a la dirección consultada: el mismo conjunto que `getSignaturesForAddress`. Si estableces `tokenAccounts` en `balanceChanged` o `all`, devuelve más resultados: agrega la actividad de las cuentas de tokens asociadas de la billetera, que el método estándar no puede detectar. ### ¿Cuánto cuesta en comparación con el patrón anterior? Obtener 1,000 transacciones completas cuesta 100 créditos con `getTransactionsForAddress`, frente a aproximadamente 1,001 créditos (y 1,001 solicitudes) con `getSignaturesForAddress` + `getTransaction`. Las respuestas que solo contienen firmas tienen un costo fijo de 10 créditos por llamada. Consulta [créditos de Helius](/docs/es/billing/credits) para ver todos los precios. ## Deja que un agente de IA realice la migración Si usas Claude Code, Cursor u otro agente de programación, pega el siguiente prompt en la sesión del agente de tu repositorio. Encontrará el patrón anterior en tu código base y lo reescribirá. ````markdown theme={"system"} Migrate this codebase from the two-step Solana transaction history pattern (getSignaturesForAddress followed by getTransaction) to the single Helius RPC method getTransactionsForAddress. ## Background getTransactionsForAddress is a Helius-exclusive JSON-RPC method served on standard Helius RPC endpoints (https://mainnet.helius-rpc.com/?api-key=...). It returns up to 1,000 full transactions per call, replacing one getSignaturesForAddress call plus one getTransaction call per signature. Docs: https://www.helius.dev/docs/rpc/gettransactionsforaddress.md ## Step 1: Find the old pattern Search for: - getSignaturesForAddress calls (via @solana/web3.js Connection, raw JSON-RPC, or another SDK) whose signatures are then passed to getTransaction / getParsedTransaction / getTransactions - Pagination loops using `before` or `until` signature cursors - getTokenAccountsByOwner calls used only to fetch per-token-account signature history Leave standalone getTransaction calls (single-signature lookups with no address context) unchanged. ## Step 2: Rewrite each call site Replace the two-step flow with one raw JSON-RPC request (web3.js has no Connection helper for this method): ```javascript const response = await fetch(HELIUS_RPC_URL, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'getTransactionsForAddress', params: [ address, // base-58 string { transactionDetails: 'full', // or 'signatures' if only signatures were used maxSupportedTransactionVersion: 1, // carry over from the old getTransaction options encoding: 'json', // carry over ('json', 'jsonParsed', 'base64', 'base58') limit: 1000, // up to 1,000 // paginationToken: '...', // from the previous response, for page 2+ // sortOrder: 'desc', // 'desc' (default, newest first) or 'asc' // filters: { ... } // optional, see mapping below } ] }) }); const { result } = await response.json(); // result.data -> array of transactions // result.paginationToken -> string cursor, or null when done ``` Parameter mapping: - limit -> limit - before: -> paginationToken (preferred) or filters: { signature: { lt: } } - until: -> filters: { signature: { gt: } } - commitment -> commitment ('confirmed' or 'finalized' only; if the old code used 'processed', use 'confirmed') - minContextSlot -> minContextSlot - encoding / maxSupportedTransactionVersion (from getTransaction) -> same names, top level of the config object Response shape: - Full mode: each entry is { slot, transactionIndex, blockTime, transaction, meta }. transaction and meta are identical in shape to getTransaction results, so existing parsing code carries over. Entries are never null - remove null-handling that existed for missing getTransaction results. - Signatures mode: entries match getSignaturesForAddress output ({ signature, slot, err, memo, blockTime, confirmationStatus }) plus transactionIndex. Pagination: loop while result.paginationToken is non-null, passing it back as paginationToken. Remove manual last-signature tracking. If the old code fetched signatures for the wallet's token accounts too (getTokenAccountsByOwner + per-account getSignaturesForAddress), replace all of it with one call using filters: { tokenAccounts: 'balanceChanged' } and delete the merge/dedupe logic. ## Step 3: Constraints and cleanup - The endpoint must be a Helius RPC URL; other providers do not serve this method. Do not change endpoints for other RPC calls. - Remove now-unused batching, throttling, and retry helpers that existed only for the getTransaction fan-out. - One request covers one address; keep parallel queries for multi-address code. - Preserve the surrounding code style and error handling conventions. ## Step 4: Verify - Run the project's type checks and tests. - Do NOT make any RPC calls yourself. Instead, write a standalone script (e.g. scripts/verify-gtfa-migration.mjs) that fetches history for one address both ways - the old getSignaturesForAddress + getTransaction flow and the new getTransactionsForAddress call with default filters - and prints whether the signature sets match, listing any differences. Read the RPC URL from an environment variable and the address from a CLI argument; never hardcode an API key. - Tell the user how to run it, for example: HELIUS_RPC_URL="https://mainnet.helius-rpc.com/?api-key=..." \ node scripts/verify-gtfa-migration.mjs
- Summarize every call site changed and flag any you were unsure about. ```` El prompt es autocontenido: el agente no necesita acceso a esta página. Para consultar documentación preparada para agentes, búsqueda mediante MCP y habilidades, consulta [Helius para agentes de IA](/docs/es/agents/overview). ## Próximos pasos Tutorial completo sobre filtros, ordenamiento, paginación y cuentas de tokens. Esquema completo de solicitudes y respuestas. Usa getTransactionsForAddress para realizar el backfill y sincronizar un índice de Solana. Compara todos los métodos de datos históricos de Solana.