> ## 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.
## Submitting Feedback
If you encounter incorrect, outdated, or confusing documentation on this page, submit feedback:
POST https://docs.chainstack.com/feedback
```json
{
"path": "/reference/ethereum-newpendingtransactionfilter",
"feedback": "Description of the issue"
}
```
Only submit feedback when you have something specific and actionable to report.
# eth_newPendingTransactionFilter | Ethereum
Ethereum API method that creates a filter that listens for new pending transactions on the blockchain. It returns a filter ID, which can be used to retrieve the results using the [eth\_getFilterChanges](/reference/ethereum-getfilterchanges) method. The `eth_newPendingTransactionFilter` method is useful for developers who must be notified of new pending transactions in real time.
**Get your own node endpoint today**
[Start for free](https://console.chainstack.com/) 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
* `none`
## Response
* `result` — a hexadecimal string representing the ID of the newly created filter
## Code examples
The filters created are stored on the blockchain client instance. The filter is automatically deleted if not polled within a certain time (5 minutes by default).
Use the following methods with the filter ID:
* [eth\_getFilterChanges](/reference/ethereum-getfilterchanges) to retrieve updates
* [eth\_uninstallFilter](/reference/ethereum-uninstallfilter) to remove the filter
## `eth_newPendingTransactionFilter` code examples
Note that the `web3.eth.filter` methods have been deprecated and replaced with the `web3.eth.subscribe` in web3.js. See [web3.js subscriptions](/reference/ethereum-web3js-subscriptions-methods).
```javascript ethers.js theme={"system"}
const ethers = require("ethers");
// Create a ChainstackProvider instance for Ethereum mainnet
const chainstack = new ethers.ChainstackProvider("mainnet");
const createFilter = async () => {
try {
const filterId = await chainstack.send(
"eth_newPendingTransactionFilter",
[]
);
console.log(filterId); // the filter ID returned by eth_newFilter
return filterId;
} catch (error) {
console.log(error);
}
};
createFilter();
```
```python web3.py theme={"system"}
from web3 import Web3
node_url = "CHAINSTACK_NODE_URL"
web3 = Web3(Web3.HTTPProvider(node_url))
def get_new_pending_transactions():
try:
blocks_filter = web3.eth.filter('pending')
# Split the string at the space character
parts = str(blocks_filter).split(' ')
# Extract the filter value from the second part
filter_id = parts[2]
return filter_id
except Exception as e:
print(e)
new_filter = get_new_pending_transactions()
print(new_filter)
```
Read [Uncovering the power of eth\_getBlockReceipts](/docs/uncovering-the-power-of-ethgetblockreceipts) to learn more about transactions receipts and how to use the `eth_getBlockReceipts` method.
## Use case
One way to use the `eth_newPendingTransactionFilter` method is to listen for new pending transactions at predefined intervals and extract specific data from them. For instance, a decentralized application might check for pending transactions every second and identify those that transfer a value greater than a certain amount of the ETH token. This could be useful for monitoring high-value transactions or detecting potential fraud or security threats in real time.
Here is an implementation of this concept using ethers.js:
```javascript index.js theme={"system"}
const ethers = require("ethers");
// Create a ChainstackProvider instance for Ethereum mainnet
const chainstack = new ethers.ChainstackProvider("mainnet");
// Create a filter using eth_newPendingTransactionFilter
const createFilter = async () => {
try {
const filterId = await chainstack.send(
"eth_newPendingTransactionFilter",
[]
);
console.log(filterId); // the filter ID returned by eth_newFilter
return filterId;
} catch (error) {
console.log(error);
}
};
// Use the filter to extract the value from each transaction
async function getValue(filter) {
try {
// Retrieve the list of new pending transactions
const transactions = await chainstack.send("eth_getFilterChanges", [
filter,
]);
// Loop through the list of transactions and process each one
for (const hash of transactions) {
const receipt = await chainstack.send("eth_getTransactionByHash", [hash]);
// Check that the receipt is not null and has a non-null value field
if (receipt && receipt.value != null) {
const value = receipt.value;
const decimalValue = BigInt(value).toString();
const convertedValue = ethers.formatEther(decimalValue);
// Check if the transferred value is greater than or equal to 100 ETH
if (convertedValue >= 100) {
console.log(`This transaction is sending more than 100 ETH`);
console.log(`Transaction Hash: ${hash}`);
console.log(`Value transferred: ${convertedValue} \n`);
}
}
}
} catch (error) {
console.error(error); // Handle errors that may occur
}
}
// Main program setting an interval to call the `getValue` function at regular intervals
async function main() {
const filterId = await createFilter();
setInterval(getValue, 1000, filterId);
}
main();
```
This code sets up an Ethereum filter to listen for new pending transactions and extract specific data from them.
The code consists of three functions: `createFilter`, `getValue`, and `main`. Here's an overview of how each function works:
The `createFilter` function sets up a new filter using the `eth_newPendingTransactionFilter` method. It returns the ID of the filter, which can be used to retrieve data from the filter later.
The `getValue` function retrieves the list of new pending transactions using the [eth\_getFilterChanges](/reference/ethereum-getfilterchanges) method and loops through each transaction. For each transaction, it retrieves the transaction data using the [eth\_getTransactionByHash](/reference/ethereum-gettransactionbyhash) method and checks if the transaction value is greater than or equal to 100 ETH. If the value is above this threshold, the function logs information about the transaction to the console.
The `main` function sets up the program by first calling the `createFilter` function to create a new filter and retrieve its ID. It then sets an interval to call the `getValue` function every 1 second, passing the filter ID as an argument to retrieve the latest transaction data at regular intervals.
## OpenAPI
````yaml /openapi/ethereum_node_api/transaction_info/eth_newPendingTransactionFilter.json POST /0a9d79d93fb2f4a4b1e04695da2b77a7
openapi: 3.0.0
info:
title: NODE API
version: 1.0.0
description: This is an API for interacting with a Chainstack node.
servers:
- url: https://nd-422-757-666.p2pify.com
security: []
paths:
/0a9d79d93fb2f4a4b1e04695da2b77a7:
post:
summary: eth_newPendingTransactionFilter
operationId: newPendingTransactionFilter
requestBody:
required: true
content:
application/json:
schema:
type: object
properties:
jsonrpc:
type: string
default: '2.0'
method:
type: string
default: eth_newPendingTransactionFilter
params:
type: array
default: []
id:
type: integer
default: 1
responses:
'200':
description: The new filter ID.
content:
application/json:
schema:
type: object
properties:
jsonrpc:
type: string
id:
type: integer
result:
type: array
items:
type: string
````