> ## 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.

# txpool_inspect | Arc

> Arc API method that returns a human-readable summary of the transactions in the node's pool, grouped by sender and nonce. Use it on Arc via Chainstack.

Arc API method that returns a human-readable summary of the transactions waiting in the node's pool. It reports the same set as [txpool\_content](/reference/arc-txpool-content), but each transaction is collapsed to a single string instead of a full object, which makes it far cheaper to poll.

## Parameters

None.

## Response

* `pending` — transactions ready for inclusion, keyed by sender address and then by nonce. Each value is a string of the form `recipient: value wei + gas gas × gasPrice wei`.
* `queued` — transactions held back because the sender's nonce sequence has a gap, in the same shape.

<Note>
  Arc produces a block roughly every 0.5 seconds, so the pool drains quickly and both objects are frequently empty. An empty result means the node had nothing pending at that moment, not that the method failed.
</Note>

## `txpool_inspect` code examples

<CodeGroup>
  ```javascript ethers.js theme={"system"}
  const { JsonRpcProvider } = require("ethers");

  const provider = new JsonRpcProvider("CHAINSTACK_NODE_URL");

  async function call() {
    const result = await provider.send("txpool_inspect", []);
    console.log(result);
  }

  call();
  ```

  ```python web3.py theme={"system"}
  from web3 import Web3

  node_url = "CHAINSTACK_NODE_URL"
  web3 = Web3(Web3.HTTPProvider(node_url))

  result = web3.provider.make_request("txpool_inspect", [])
  print(result)
  ```

  ```shell cURL theme={"system"}
  curl -X POST "CHAINSTACK_NODE_URL" \
    -H "Content-Type: application/json" \
    --data '{
      "jsonrpc": "2.0",
      "method": "txpool_inspect",
      "params": [],
      "id": 1
    }'
  ```
</CodeGroup>

## Use case

Use `txpool_inspect` when you want to know whether a sender has transactions stuck in the pool without pulling every field of every transaction. Because a nonce gap parks everything behind it in `queued`, this is the fastest way to see that a sender is blocked and which nonce is missing.


## OpenAPI

````yaml openapi/arc_node_api/txpool/txpool_inspect.json POST /
openapi: 3.0.0
info:
  title: Chainstack Node API
  version: 1.0.0
  description: This is an API for interacting with a Chainstack node.
servers:
  - url: https://arc-testnet.core.chainstack.com/6caa7fd90475ac9214f7521dd460fa7c
security: []
paths:
  /:
    post:
      tags:
        - upload
      summary: txpool_inspect
      operationId: txpool_inspect
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              properties:
                id:
                  type: integer
                  default: 1
                jsonrpc:
                  type: string
                  default: '2.0'
                method:
                  type: string
                  default: txpool_inspect
                params:
                  type: array
                  default: []
      responses:
        '200':
          description: Returns the result of txpool_inspect.
          content:
            application/json:
              schema:
                type: object
                properties:
                  jsonrpc:
                    type: string
                  id:
                    type: integer
                  result:
                    type: object
                    properties:
                      pending:
                        type: object
                        properties: {}
                      queued:
                        type: object
                        properties: {}
              example:
                jsonrpc: '2.0'
                id: 1
                result:
                  pending: {}
                  queued: {}

````