eth_getTransactionCount | Polygon RPC Docs

Get the number of transactions sent from an address (nonce) on Polygon. Essential for nonce management, transaction signing, and detecting stuck transactions.

Returns the number of transactions sent from an address on Polygon, commonly known as the nonce. The nonce is required for every outbound transaction to ensure correct ordering and prevent replay attacks.

Why Polygon? Build on the most adopted Ethereum scaling solution with 45,000+ dApps and enterprise partnerships with $4B+ TVL, sub-$0.01 transactions, 8M+ daily transactions, and zkEVM for enhanced security.

When to Use This Method

eth_getTransactionCount is essential for enterprise developers, gaming studios, and teams building high-throughput applications:

Transaction Signing — Get the correct nonce before building and signing a new transaction on Polygon
Nonce Gap Detection — Compare latest and pending nonces to identify stuck or dropped transactions in the mempool
Account Activity Analysis — Track the total number of outgoing transactions from any address on enterprise solutions (Starbucks, Disney, Reddit), gaming, DeFi, and stablecoin payments
Batch Transaction Sequencing — Assign sequential nonces when submitting multiple transactions from the same address

Code Examples

Common Use Cases

1. Safe Transaction Sender with Nonce Management

Build a transaction sender that handles nonces correctly on Polygon:

JavaScript

import { JsonRpcProvider, Wallet, parseEther } from 'ethers';

const provider = new JsonRpcProvider('https://api-polygon-mainnet-full.n.dwellir.com/YOUR_API_KEY');

class TransactionSender {
  constructor(privateKey) {
    this.wallet = new Wallet(privateKey, provider);
    this.localNonce = null;
  }

  async getNextNonce() {
    // Get the pending nonce from the network
    const pendingNonce = await provider.getTransactionCount(
      this.wallet.address, 'pending'
    );

    // Use whichever is higher: local tracker or network pending
    if (this.localNonce === null || pendingNonce > this.localNonce) {
      this.localNonce = pendingNonce;
    }

    const nonce = this.localNonce;
    this.localNonce++;
    return nonce;
  }

  async sendTransaction(to, valueEth) {
    const nonce = await this.getNextNonce();

    const tx = await this.wallet.sendTransaction({
      to,
      value: parseEther(valueEth),
      nonce
    });

    console.log(`Sent tx ${tx.hash} with nonce ${nonce}`);
    return tx;
  }

  // Reset local nonce tracker (e.g., after errors)
  resetNonce() {
    this.localNonce = null;
  }
}

2. Stuck Transaction Detector

Detect and report stuck transactions by comparing nonces:

JavaScript

async function detectStuckTransactions(provider, address) {
  const confirmedNonce = await provider.getTransactionCount(address, 'latest');
  const pendingNonce = await provider.getTransactionCount(address, 'pending');

  const pendingCount = pendingNonce - confirmedNonce;

  if (pendingCount === 0) {
    console.log('No pending transactions');
    return { status: 'clear', pendingCount: 0 };
  }

  console.log(`${pendingCount} pending transaction(s) detected`);
  console.log(`Confirmed nonce: ${confirmedNonce}`);
  console.log(`Pending nonce: ${pendingNonce}`);
  console.log(`Stuck nonces: ${confirmedNonce} to ${pendingNonce - 1}`);

  return {
    status: 'stuck',
    pendingCount,
    confirmedNonce,
    pendingNonce,
    stuckNonces: Array.from(
      { length: pendingCount },
      (_, i) => confirmedNonce + i
    )
  };
}

// Usage
const result = await detectStuckTransactions(provider, '0x8D97689C9818892B700e27F316cc3E41e17fBeb9');
if (result.status === 'stuck') {
  console.log('Consider replacing transactions at nonces:', result.stuckNonces);
}

3. Batch Transaction Submitter

Submit multiple transactions in sequence with correct nonce ordering:

JavaScript

async function sendBatchTransactions(wallet, transactions) {
  const startNonce = await provider.getTransactionCount(
    wallet.address, 'pending'
  );

  console.log(`Sending ${transactions.length} transactions starting at nonce ${startNonce}`);

  const receipts = [];
  for (let i = 0; i < transactions.length; i++) {
    const nonce = startNonce + i;
    const tx = await wallet.sendTransaction({
      ...transactions[i],
      nonce
    });

    console.log(`Tx ${i + 1}/${transactions.length} sent: ${tx.hash} (nonce: ${nonce})`);
    receipts.push(tx);
  }

  // Wait for all to confirm
  const confirmed = await Promise.all(
    receipts.map(tx => tx.wait())
  );

  console.log(`All ${confirmed.length} transactions confirmed`);
  return confirmed;
}

// Usage
const transactions = [
  { to: '0xRecipient1...', value: parseEther('0.1') },
  { to: '0xRecipient2...', value: parseEther('0.2') },
  { to: '0xRecipient3...', value: parseEther('0.05') }
];

await sendBatchTransactions(wallet, transactions);

Error Handling

Common errors and solutions:

Error Code	Description	Solution
-32602	Invalid params	Verify the address is a valid 20-byte hex string and the block parameter is valid
-32603	Internal error	Retry with exponential backoff
-32000	Block not found	The requested block may be pruned — use `latest` or `pending`
-32005	Rate limit exceeded	Implement caching for nonce lookups

JavaScript

async function safeGetNonce(provider, address, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await provider.getTransactionCount(address, 'pending');
    } catch (error) {
      if (error.code === -32005) {
        await new Promise(r => setTimeout(r, Math.pow(2, i) * 1000));
        continue;
      }
      if (i === maxRetries - 1) throw error;
      await new Promise(r => setTimeout(r, Math.pow(2, i) * 1000));
    }
  }
}

eth_sendRawTransaction — Send a signed transaction to the network
eth_getBalance — Get the ETH balance of an address
eth_getTransactionByHash — Get transaction details by hash
eth_getTransactionReceipt — Get the receipt of a confirmed transaction

eth_getTransactionCount - Polygon RPC Method

When to Use This Method

Code Examples

Common Use Cases

1. Safe Transaction Sender with Nonce Management

2. Stuck Transaction Detector

3. Batch Transaction Submitter

Error Handling

On this page