> ## 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.
# Cómo usar getSignaturesForAddress
> Conoce los casos de uso, ejemplos de código, parámetros de solicitud, estructura de respuesta y consejos de getSignaturesForAddress.
El método RPC [`getSignaturesForAddress`](https://www.helius.dev/docs/api-reference/rpc/http/getsignaturesforaddress) te permite recuperar una lista de firmas de transacciones confirmadas que involucran una dirección de cuenta específica. Esto resulta útil para obtener el historial de transacciones de una cuenta. Las firmas se devuelven en orden cronológico inverso (primero las más recientes).
Para obtener funciones avanzadas de filtrado y ordenamiento, además del historial de cuentas de tokens, usa [`getTransactionsForAddress`](/docs/es/rpc/gettransactionsforaddress). Ten en cuenta que `getSignaturesForAddress` no incluye las transacciones que involucran cuentas de tokens asociadas.
## Casos de uso comunes
* **Historial de transacciones de una cuenta:** Muestra las transacciones anteriores de la billetera de un usuario. Para un análisis más avanzado del historial de transacciones, considera usar la [API de transacciones mejoradas](https://www.helius.dev/docs/enhanced-transactions) de Helius.
* **Auditoría de actividad:** Revisa todas las transacciones asociadas con un contrato inteligente o una cuenta específicos.
* **Búsqueda de una transacción específica:** Busca una transacción específica recorriendo el historial de una cuenta si solo se conoce la dirección involucrada.
* **Indexación de datos:** Crea un índice local de transacciones para agilizar las consultas y el análisis.
## Parámetros de la solicitud
1. **`address`** (`string`): (Obligatorio) La clave pública codificada en base 58 de la cuenta cuyas firmas de transacciones se recuperarán.
2. **`options`** (`object`, opcional): Un objeto de configuración opcional con los siguientes campos:
* **`limit`** (`number`, opcional): El número máximo de firmas que se devolverán. El valor predeterminado es 1000 y el máximo permitido es 1000.
* **`before`** (`string`, opcional): Una firma de transacción codificada en base 58. Si se proporciona, la consulta comenzará a buscar transacciones anteriores a esta firma.
* **`until`** (`string`, opcional): Una firma de transacción codificada en base 58. Si se proporciona, la consulta buscará transacciones hasta llegar a esta firma, sin incluirla.
* **`commitment`** (`string`, opcional): Especifica el [nivel de compromiso](https://www.helius.dev/blog/solana-commitment-levels) que se usará en la consulta. Los valores admitidos son `finalized` o `confirmed`. No se admite el compromiso `processed`. Si se omite, se usa el compromiso predeterminado del nodo RPC (normalmente `finalized`).
* **`minContextSlot`** (`number`, opcional): El slot mínimo en el que se puede evaluar la solicitud. No es un filtro de transacciones históricas, sino que establece el slot mínimo para el contexto del nodo.
**No se admite el procesamiento por lotes**
Este método de archivo no admite el procesamiento por lotes. Realiza únicamente solicitudes individuales.
## Estructura de la respuesta
El campo `result` de la respuesta JSON-RPC es un arreglo de objetos con información de las firmas. Cada objeto tiene la siguiente estructura:
* **`signature`** (`string`): La firma de la transacción codificada en base 58.
* **`slot`** (`u64`): El slot en el que se procesó la transacción.
* **`err`** (`object` | `null`): Un objeto de error si la transacción falló, o `null` si se realizó correctamente.
* **`memo`** (`string` | `null`): La nota asociada con la transacción, si existe.
* **`blockTime`** (`i64` | `null`): El tiempo estimado de producción del bloque que contiene la transacción, como marca de tiempo Unix (segundos desde la época). `null` si no está disponible.
* **`confirmationStatus`** (`string` | `null`): El estado de confirmación de la transacción (por ejemplo, `processed`, `confirmed`, `finalized`). `null` si no está disponible (por ejemplo, en respuestas antiguas de Helius).
## Ejemplos
### 1. Obtén las firmas más recientes de una dirección
Este ejemplo obtiene las firmas de transacciones más recientes (hasta 1000) de una dirección determinada.
```bash cURL theme={"system"}
# Replace with your Helius API key
# Replace SYSTEM_PROGRAM_ID with the address you want to query
curl https://mainnet.helius-rpc.com/?api-key= -X POST -H "Content-Type: application/json" -d \
'{
"jsonrpc": "2.0",
"id": 1,
"method": "getSignaturesForAddress",
"params": [
"11111111111111111111111111111111"
]
}'
```
```javascript JavaScript (using @solana/web3.js) theme={"system"}
// Replace with your Helius API key
const { Connection, PublicKey } = require('@solana/web3.js');
async function getLatestSignatures() {
const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=');
// Replace with the public key you want to query
const address = new PublicKey('11111111111111111111111111111111');
try {
const signatures = await connection.getSignaturesForAddress(address);
if (signatures && signatures.length > 0) {
console.log(`Found ${signatures.length} signatures:`);
signatures.forEach((sigInfo, index) => {
console.log(`--- Signature ${index + 1} ---`);
console.log(` Signature: ${sigInfo.signature}`);
console.log(` Slot: ${sigInfo.slot}`);
console.log(` Block Time: ${sigInfo.blockTime ? new Date(sigInfo.blockTime * 1000).toLocaleString() : 'N/A'}`);
console.log(` Error: ${JSON.stringify(sigInfo.err)}`);
console.log(` Memo: ${sigInfo.memo || 'N/A'}`);
console.log(` Confirmation Status: ${sigInfo.confirmationStatus || 'N/A'}`);
});
} else {
console.log('No signatures found for this address.');
}
} catch (error) {
console.error('Error fetching signatures:', error);
}
}
getLatestSignatures();
```
### 2. Obtén firmas con un límite
Este ejemplo obtiene un número específico de firmas de transacciones recientes de una dirección.
```bash cURL theme={"system"}
# Replace with your Helius API key
# Replace TARGET_ACCOUNT_ADDRESS with the address you want to query
curl https://mainnet.helius-rpc.com/?api-key= -X POST -H "Content-Type: application/json" -d \
'{
"jsonrpc": "2.0",
"id": 1,
"method": "getSignaturesForAddress",
"params": [
"TARGET_ACCOUNT_ADDRESS",
{
"limit": 5
}
]
}'
```
```javascript JavaScript (using @solana/web3.js) theme={"system"}
// Replace with your Helius API key
const { Connection, PublicKey } = require('@solana/web3.js');
async function getLimitedSignatures() {
const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=');
// Replace with the public key you want to query
const address = new PublicKey('Vote111111111111111111111111111111111111111');
const limit = 5;
try {
const signatures = await connection.getSignaturesForAddress(address, { limit });
console.log(`Fetched up to ${limit} signatures:`);
signatures.forEach((sigInfo, index) => {
console.log(`${index + 1}. Signature: ${sigInfo.signature}, Slot: ${sigInfo.slot}`);
});
} catch (error) {
console.error(`Error fetching limited signatures for ${address.toBase58()}:`, error);
}
}
getLimitedSignatures();
```
### 3. Pagina el historial de transacciones
Este ejemplo muestra cómo obtener el historial de transacciones en lotes mediante el parámetro `before`.
```bash cURL theme={"system"}
# Initial request (get the latest 2)
# Replace with your Helius API key
# Replace TARGET_ACCOUNT_ADDRESS with the address you want to query
curl https://mainnet.helius-rpc.com/?api-key= -X POST -H "Content-Type: application/json" -d \
'{
"jsonrpc": "2.0",
"id": 1,
"method": "getSignaturesForAddress",
"params": [
"TARGET_ACCOUNT_ADDRESS",
{ "limit": 2 }
]
}'
# Suppose the last signature from the above response was LAST_SIGNATURE_FROM_PREVIOUS_BATCH
# Fetch the next 2 transactions before that one
curl https://mainnet.helius-rpc.com/?api-key= -X POST -H "Content-Type: application/json" -d \
'{
"jsonrpc": "2.0",
"id": 1,
"method": "getSignaturesForAddress",
"params": [
"TARGET_ACCOUNT_ADDRESS",
{
"limit": 2,
"before": "LAST_SIGNATURE_FROM_PREVIOUS_BATCH"
}
]
}'
```
```javascript JavaScript (using @solana/web3.js) theme={"system"}
// Replace with your Helius API key
const { Connection, PublicKey } = require('@solana/web3.js');
async function paginateSignatures() {
const connection = new Connection('https://mainnet.helius-rpc.com/?api-key=');
// Replace with the public key you want to query - e.g. a known active address
const address = new PublicKey('Vote111111111111111111111111111111111111111');
const batchSize = 2;
let lastSignature = null;
let allSignatures = [];
const maxPages = 3; // Limit how many pages we fetch for this example
try {
for (let i = 0; i < maxPages; i++) {
console.log(`Fetching page ${i + 1}...`);
const options = { limit: batchSize };
if (lastSignature) {
options.before = lastSignature;
}
const signatures = await connection.getSignaturesForAddress(address, options);
if (signatures.length === 0) {
console.log('No more signatures found.');
break;
}
signatures.forEach(sigInfo => {
allSignatures.push(sigInfo.signature);
console.log(` Found: ${sigInfo.signature} in slot ${sigInfo.slot}`);
});
lastSignature = signatures[signatures.length - 1]?.signature;
if (signatures.length < batchSize || !lastSignature) {
console.log('Fetched all available signatures or reached end of page.');
break;
}
// Optional: Add a small delay if making many sequential requests
// await new Promise(resolve => setTimeout(resolve, 200));
}
console.log(`
Total signatures fetched (${allSignatures.length}):`);
allSignatures.forEach((sig, idx) => console.log(`${idx + 1}. ${sig}`));
} catch (error) {
console.error('Error paginating signatures:', error);
}
}
paginateSignatures();
```
## Consejos para desarrolladores
* **Paginación:** Para obtener el historial de transacciones completo de una cuenta activa, probablemente necesites realizar varias solicitudes. Usa el parámetro `before` con la última firma recibida en el lote anterior y un valor `limit`.
* **Límites de solicitudes:** Ten en cuenta los límites de solicitudes del nodo RPC cuando obtengas historiales de transacciones extensos.
* **Orden:** Las firmas siempre se devuelven desde la más reciente hasta la más antigua.
* **Parámetro `limit`:** El parámetro `limit` puede tener un valor entre 1 y 1000. Si no se especifica, su valor predeterminado es 1000.
* **Parámetro `until`:** Este parámetro puede usarse para dejar de obtener firmas al llegar a una firma antigua conocida. Puede ser útil si solo necesitas las transacciones hasta un punto determinado.
* **`minContextSlot`:** Este parámetro no filtra las transacciones históricas. Especifica el slot mínimo que el nodo RPC debe usar como contexto al evaluar la solicitud. Si el estado del nodo es anterior a este slot, puede devolver un error.
* **Detalles de la transacción:** Este método solo devuelve firmas e información básica. Para obtener todos los detalles de una transacción, usa el método `getTransaction` con cada firma.
* **Limitación de cuentas de tokens:** Este método solo devuelve transacciones que hacen referencia directa a la dirección proporcionada. No incluye transacciones que involucran cuentas de tokens propiedad de la dirección. Para obtener un historial completo de tokens, incluidas las cuentas de tokens asociadas, usa [`getTransactionsForAddress`](/docs/es/rpc/gettransactionsforaddress) con el filtro `tokenAccounts`.
Al usar `getSignaturesForAddress` con sus opciones de paginación, puedes recuperar y administrar eficazmente los historiales de transacciones de cualquier dirección de Solana.
## Métodos relacionados
Filtrado y ordenamiento avanzados, e historial de cuentas de tokens
Obtén todos los detalles de una transacción a partir de una firma