---
license: odc-by
pretty_name: "Bitcoin mempool lifecycle, dwell times and fee estimates"
tags:
  - mempool
  - transaction-fees
  - fee-estimation
  - bitcoin
  - litecoin
  - ethereum
  - blockchain
  - cryptocurrency
  - time-series
task_categories:
  - time-series-forecasting
size_categories:
  - 1M<n<10M
---

# Bitcoin mempool lifecycle

Transactions from the moment they appear in the mempool to whatever happens to them: mined,
still waiting, or dropped without ever reaching a block.

A confirmed transaction keeps its contents forever but loses its timing. One that is never mined
leaves no record at all. Both are recorded here as they happen.

## Contents

| name | one row is |
|---|---|
| `e8_btc_mempool_lifecycle` | a Bitcoin transaction: first seen, fee rate, mined height, blocks waited, fate |
| `e9_btc_mempool_divergence` | one view of the pending set at one instant, sized and compared against the others |
| `e11_ltc_mempool_lifecycle` | the same, for Litecoin |
| `e15_fee_estimators` | one fee estimate from one provider at one moment, with its target |
| `e1_mempool_lifecycle` | an Ethereum transaction seen pending (ends 2026-08-26, see below) |
| `e1_mempool_minutely` | one minute of Ethereum mempool activity |
| `e1_mempool_dropped` | an Ethereum transaction that was never mined |
| `e3_mempool_divergence` | Ethereum pending-set comparison across views |
| `e21_btc_relay_floor` | one peer's own minimum relay fee, at the moment it announced it |

`e1_mempool_lifecycle` stops at 2026-08-26. Per-transaction Ethereum rows were discontinued
there: the Flashbots Mempool Dumpster publishes the same measurement under CC-0 from a wider
node set, so a duplicate was not worth the storage it took. `e1_mempool_minutely` and
`e1_mempool_dropped` continue. The earlier partitions are kept and keep their own name, so
nothing joins them to the newer tables and reads a change of population as a trend.

## Fee rate coverage

`fee_rate_sat_vb` is present on a portion of rows and that portion changes over time. It is
sampled, never estimated: a guessed fee rate would ruin the analyses the column exists for.

Coverage by day, as a share of transactions observed arriving (`pre_existing == False`):

| date | coverage |
|---|---|
| 2026-08-25 | none |
| 2026-08-26 | ~4% |
| 2026-08-27 | ~14% |
| 2026-08-28 | ~16% early, ~67% late |
| 2026-08-29 onward | ~67% |

Coverage of transactions already pending when a collection window opened moved from about 1% to
about 99% on 2026-08-28. Dropped rows inherit that figure and reached 94% on 2026-08-29.

Partitions from 2026-08-29 are substantially denser than earlier ones. Compute coverage per
partition rather than assuming a constant:

```python
obs = df[~df.pre_existing.astype(bool)]
coverage = obs.fee_rate_sat_vb.notna().mean()
```

Rows without a fee rate are complete in every other respect, so they remain usable for lifecycle
work. Only fee-conditioned analysis is affected.

## Reading the fate column

`dropped` means the transaction was confirmed absent from the chain, absent from every pending
view held, and stayed absent through a debounce period. It is not inferred from a single
observation. `unresolved` means it went missing but could not be confirmed, and is never counted
as a drop.

Bitcoin `fate = "dropped"` begins 2026-08-26. Earlier partitions contain no drops because a
defect made them impossible to record, not because none occurred.

## Package fee rates

A transaction's own fee rate is not what decides whether it is mined. A miner sorts by the
ANCESTOR fee rate, so a transaction with an unconfirmed low-fee parent is worth less than it
appears, and a child paying a large fee lifts its parent with it.

`effective_fee_rate_sat_vb` is `ancestor_fees_sat / ancestor_vsize`. For a transaction with no
unconfirmed parents it equals `fee_rate_sat_vb` exactly; where they diverge, the effective rate
is the one that governs inclusion. One snapshot held a transaction paying 28.4 sat/vB whose
effective rate was 2.1.

`ancestor_count` above 1 marks membership in an unconfirmed chain, which is how fee bumping by
a child shows up. The descendant columns are the mirror: what is waiting on this transaction.

These come from a full node's own view, so they are null for transactions it never held, and
they are recorded as first observed. Package structure changes as parents confirm, so treat
them as the state at first sight rather than a running value.

## Relay floors

A transaction below a node's minimum relay fee is not merely deprioritised: that node will not
forward it, so it never reaches the miners at all. Every peer announces its own floor on
connect and again whenever it moves, and those announcements are kept by nobody.

`e21_btc_relay_floor` is one row per announcement, so a peer appears repeatedly as its floor
changes. `min_relay_fee_sat_kvb` is the wire value; `min_relay_fee_sat_vb` is the same number
in the units fee tools quote.

Expect little variation while the mempool is quiet, because nodes then sit at whatever they
were configured with. The floor moves when a mempool fills and starts evicting, which is
exactly when it matters and exactly when it cannot be reconstructed afterwards.

## Before you build on this

- Pending sets are node-local. What one view holds is not what the network holds, and retention
  is a configuration choice rather than a protocol rule. `e9` exists to size that disagreement,
  and it is large: at one instant the views ranged from about 6,000 to about 87,000 pending
  transactions, with only 7% common to all of them.
- Dropped rows carry a fee rate far less often than mined rows. Every drop observed so far was
  already pending when its window opened, and fee sampling favours arrivals.
- A fee rate of exactly 0 is real and rare. Filter on `fee_rate_sat_vb > 0` if a zero would
  break your arithmetic rather than treating it as a decode fault.
- Timestamps are ours, taken at observation. They are not consensus timestamps and carry our
  network distance to whatever served the data.
- Ethereum rows are included for comparison. If Ethereum is your subject, the Flashbots Mempool
  Dumpster publishes the same measurement daily under CC-0 from a wider node set and a longer
  history. Theirs is better; use it.

Partitions are parquet, one file per collection window, under `dataset/YYYY/MM/`. This repo carries a FIXED 7-day sample (2026-08-25 to 2026-08-31) so you can check schema, coverage and quality before asking for more. It does not advance, so there is nothing to gain by re-downloading it. The full history is held privately, available on request.

```python
from huggingface_hub import snapshot_download
import pandas as pd, glob

path = snapshot_download("dataforge-labs/bitcoin-mempool-lifecycle", repo_type="dataset",
                         allow_patterns="e8_btc_mempool_lifecycle/**")
df = pd.concat(map(pd.read_parquet,
                   glob.glob(f"{path}/e8_btc_mempool_lifecycle/**/*.parquet", recursive=True)))
```

## Coverage

`e0_run_manifest` lists every collection window with its poll counts and failure counts, and is
published in full rather than windowed. Gaps between windows are real, cannot be filled in
afterwards, and nothing here is interpolated.

## License and contact

ODC-BY: use it freely, credit "DataForge (dataforge-labs)". Questions and requests for the full
history via the discussions tab.