> ## 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.
# eth_newPendingTransactionFilter | Polygon
> Polygon API method that creates a filter that listens for new pending transactions on the blockchain. Chainstack Polygon reference.
Polygon 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` method. The `eth_newPendingTransactionFilter` method is useful for developers who must be notified of new pending transactions in real time.
## 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` to retrieve updates
* `eth_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/polygon-web3js-subscriptions-methods).
```javascript ethers.js theme={"system"}
const ethers = require('ethers');
const NODE_URL = "CHAINSTACK_NODE_URL";
const provider = new ethers.JsonRpcProvider(NODE_URL);
const createFilter = async () => {
try {
const filterId = await provider.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)
```
## 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 MATIC 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');
const NODE_URL = "CHAINSTACK_NODE_URL";
const provider = new ethers.JsonRpcProvider(NODE_URL);
// Create a filter using eth_newPendingTransactionFilter
const createFilter = async () => {
try {
const filterId = await provider.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 provider.send('eth_getFilterChanges', [filter]);
// Loop through the list of transactions and process each one
for (const hash of transactions) {
const receipt = await provider.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.utils.formatEther(decimalValue);
// Check if the transferred value is greater than or equal to 100 Matic
if (convertedValue >= 100) {
console.log(`This transaction is sending more than 100 Matic`);
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 `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/polygon_node_api/transaction_info/eth_newPendingTransactionFilter.json POST /a9bca2f0f84b54086ceebe590316fff3
openapi: 3.0.0
info:
title: Polygon Node API
version: 1.0.0
description: This is an API for interacting with a Polygon node.
servers:
- url: https://nd-828-700-214.p2pify.com
security: []
paths:
/a9bca2f0f84b54086ceebe590316fff3:
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
````