> ## Documentation Index
> Fetch the complete documentation index at: https://docs.chainstack.com/llms.txt
> Use this file to discover all available pages before exploring further.

# subscribe ("pendingTransactions") | Avalanche

> Reference docs for the subscribe ("pendingTransactions") JSON-RPC method on the Avalanche blockchain, available via Chainstack JSON-RPC nodes.

Note that because the Avalanche mempool is [only accessible to validators](https://docs.chainstack.com/docs/mempool-configuration.md), this method will only return transactions that were submitted through the same node you are connected to.

The ethers.js subscription equivalent to [eth\_newPendingTransactionFilter](https://docs.chainstack.com/reference/avalanche-newpendingtransactionfilter.md). `subscribe("pendingTransactions")` allows developers to subscribe to real-time updates about pending transactions on the Avalanche blockchain; the application will receive notifications whenever a pending transaction appears on the blockchain.

## Parameters

* `string` — a keyword identifying the type of event to subscribe to, `pendingTransactions` in this case.
* `function` — (optional) a callback function that will be called every time a new event of the specified type is received. This function takes two parameters: `error` and `result`. The error parameter contains any error that occurred while subscribing to the event, and the result parameter contains the data for the event that was received.

## Response

* `string` — the hash identifying the pending transaction.

## `subscribe("pendingTransactions")` code example

> [!NOTE]
>
> Note that ethers.js subscriptions require a WebSocket connection.

Use the `provider.on` method with the `"pending"` event to attach a listener to the WebSocket provider:

* `"pending"` — fires for each new pending transaction hash received by the connected node.
* `"error"` — fires if an error is detected on the provider connection.
* `provider.removeAllListeners` — removes the listeners so the program can stop receiving updates.

```javascript index.js theme={"system"}
const { ethers } = require("ethers");
const NODE_URL = "CHAINSTACK_WSS_URL";
const provider = new ethers.WebSocketProvider(NODE_URL);

async function subscribeToPendingTransactions() {
    try {
        // Subscribe to the 'pending' event to receive new pending transaction hashes
        provider.on("pending", handleNewPending);

        // Attach an error listener to the provider connection
        provider.on("error", handleError);

        console.log("New subscription: pending");
    } catch (error) {
        console.error(`Error subscribing to pending transactions: ${error}`);
    }
}

/* Fallback functions to react to the different events */

// Event listener that logs the received pending transaction hashes
function handleNewPending(transactionHash) {
    console.log(transactionHash);
}

// Event listener that logs any errors that occur
function handleError(error) {
    console.error(`Error receiving new blocks: ${error}`);
}

subscribeToPendingTransactions();
```

## Use case

A practical use case for `subscribe("pendingTransactions")` is a DApp that continuously listens for new pending transactions, then isolates the `from`, `to`, and `value` fields for analytics purposes. This is useful, for example, to only track transactions that move at least a certain amount of AVAX.

The following is an implementation of this concept using ethers.js subscriptions:

```javascript index.js theme={"system"}
const { ethers } = require("ethers");
const NODE_URL = "CHAINSTACK_WSS_URL";
const provider = new ethers.WebSocketProvider(NODE_URL);

async function subscribeTopendingTransactions() {
    try {
        // Subscribe to the 'pending' event to receive new pending transaction hashes
        provider.on("pending", handleNewPending);

        // Attach an error listener to the provider connection
        provider.on("error", handleError);

        console.log("New subscription: pending");
    } catch (error) {
        console.error(`Error subscribing to new blocks: ${error}`);
    }
}

// Use this function to unsubscribe and exit the program
function unsubscribe() {
    provider.removeAllListeners();
    console.log("Successfully unsubscribed!");
    return process.exit(1);
}

/* Fallback functions to react to the different events */

// Event listener that logs the received pending transactions and extracts from, to, and value fields
async function handleNewPending(transactionHash) {
    try {
        const transaction = await provider.getTransaction(transactionHash);
        if (!transaction) return; // The transaction may not be available yet
        const from = transaction.from;
        const to = transaction.to;
        const value = transaction.value;
        if (value >= 100000000000000000000n) { // 100 AVAX in wei
            console.log(`----- New pending transaction ------`);
            console.log(`From: ${from}`)
            console.log(`To: ${to}`)
            console.log(`Value: ${Number(ethers.formatEther(value)).toFixed(2)} AVAX\n`)
        }
    } catch (error) {
        console.error(`Error getting transaction: ${error}`);
    }
}

// Event listener that logs any errors that occur
function handleError(error) {
    console.error(`Error receiving new blocks: ${error}`);
}

subscribeTopendingTransactions();
```

This code creates a new subscription to the `pending` event using the `provider.on` method on a `WebSocketProvider`. This method attaches a listener that the provider calls every time a new pending transaction hash arrives.

The code defines two event listener functions that are attached to the provider: `handleNewPending` and `handleError`. The `handleNewPending` function is called when a new pending transaction is received; it runs the [eth\_getTransactionByHash](https://docs.chainstack.com/reference/avalanche-gettransactionbyhash.md) method through `provider.getTransaction` and extracts the `from`, `to`, and `value` fields. If the value transferred is above 100 AVAX, the data is logged.

The code includes the `unsubscribe` function that can be implemented in the logic to remove the listeners and exit the program when a condition is met.

The `handleError` function is called when an error occurs, and it logs an error message.

Finally, the code calls the `subscribeTopendingTransactions` function, which creates the subscription and attaches the event listeners. When a new pending transaction is received, the `handleNewPending` function is called to extract the data and log it to the console.
