Skip to main content
Note that because the Avalanche mempool is only accessible to validators, 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. 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.

​
Get your own node endpoint today

Start for free and get your app to production levels immediately. No credit card required.You can sign up with your GitHub, X, Google, or Microsoft account.

​
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 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.
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: 
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 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.
Last modified on June 25, 2026