---
license: apache-2.0
language:
  - en
pretty_name: US Treasury Events (point-in-time, auctions and official curves)
size_categories:
  - 100K<n<1M
task_categories:
  - tabular-regression
  - time-series-forecasting
tags:
  - finance
  - treasury
  - auctions
  - yield-curve
  - interest-rates
  - point-in-time
  - tips
  - ziplime
configs:
  - config_name: pit
    data_files:
      - split: train
        path: "data/pit/*.parquet"
  - config_name: auction_results
    data_files:
      - split: train
        path: "data/auction_results/*.parquet"
  - config_name: auction_calendar
    data_files:
      - split: train
        path: "data/auction_calendar/*.parquet"
  - config_name: auction_announcements
    data_files:
      - split: train
        path: "data/auction_announcements/*.parquet"
  - config_name: nominal_yield_curve
    data_files:
      - split: train
        path: "data/nominal_yield_curve/*.parquet"
  - config_name: real_yield_curve
    data_files:
      - split: train
        path: "data/real_yield_curve/*.parquet"
  - config_name: bill_rates
    data_files:
      - split: train
        path: "data/bill_rates/*.parquet"
  - config_name: curve_features
    data_files:
      - split: train
        path: "data/curve_features/*.parquet"
---

# US Treasury Events

Every Treasury auction since 1979 and every official daily yield curve since
1990 — and, for each of them, **the instant it became public**.

**11 114 auctions · 11 108 results · 113 836 nominal curve points ·
34 141 real · 26 453 bill rates · 268 960 point-in-time rows ·
October 1979 to today**

The pipeline lives in [`recipe/`](recipe/) at the same revision as the data.
See [PIPELINE.md](PIPELINE.md) for the method.

## Two timestamps, and the reason they are in one dataset

An auction result and a yield curve are dated in opposite ways, and a strategy
that reads both has to respect both.

### The auction states its own minute

The Treasury publishes a small artifact for every auction since March 2008, and
it settles the question outright:

```xml
<CompetitiveClosingTime>13:00</CompetitiveClosingTime>
<ReleaseTime>13:02</ReleaseTime>
```

Two minutes after the close, stated by the Treasury. That is `knowledge_at`,
and `knowledge_time_precision` is `minute`.

**4 872 results carry a stated release minute**, the first on 7 April 2008. The
other **6 236** do not, and say so.

Before March 2008 there is no artifact. Those results are dated to the end of
the auction day, because the alternative — assuming the result was public at
the close — would hand a backtest the number minutes before anyone had it, on
every auction for twenty-nine years.

### The curve does not

This is the line most Treasury datasets get wrong, so it is worth quoting the
Treasury directly. Its
[methodology page](https://home.treasury.gov/policy-issues/financing-the-government/interest-rate-statistics/treasury-yield-curve-methodology)
says the inputs are

> indicative, bid-side market price quotations (not actual transactions) for
> the most recently auctioned securities obtained by the Federal Reserve Bank
> of New York **at or near 3:30 PM** each trading day

and, further down the same page,

> Yield curve rates are **usually available** at Treasury's interest rate
> website **by 6:00 PM Eastern Time** each trading day, but may be delayed due
> to system problems or other issues.

Those are two different instants. 3:30 p.m. is what the number measures;
6:00 p.m. is when anyone could read it. So every curve row carries both:

| Column | |
|---|---|
| `market_observation_at` | 15:30 Eastern — what the number describes |
| `knowledge_at` | **18:00 Eastern** — when it could be read |
| `knowledge_time_precision` | `modeled_conservative` |
| `availability_time_basis` | `treasury_usually_available_by_1800_et` |

Dating a curve to 3:30 p.m. would hand a backtest two and a half hours of the
afternoon it did not have, every trading day for thirty-five years. The gate
fails the build if any curve row is knowable before 18:00 Eastern, and
`tests/test_quality.py` proves the check by breaking it.

## What is deliberately missing

**`wi_yield` and `auction_tail` are null on every row, and the gate fails the
build if either is ever populated.**

The tail is the auction's high yield minus the when-issued market yield. No
official point-in-time when-issued series exists. The daily par yield curve is
not one — it is struck from indicative quotations at 3:30 p.m., hours after most
auctions close — and subtracting it from the high yield produces a plausible
number measuring something else. A column called `auction_tail` that does not
contain an auction tail is worse than no column at all.

## A null is not a zero

The Treasury did not start publishing all of this at once, and the differences
are large enough to change an analysis.

| | Begins |
|---|---|
| auction query | October 1979 |
| bidder categories — indirect, direct, primary dealer | **2008** |
| the artifact that states the release minute | **April 2008** |
| nominal par yield curve | January 1990 |
| bill rates | January 2002 |
| TIPS real yield curve | January 2003 |

Read a 1995 auction expecting an indirect bid share and you get null, because
the Treasury did not publish one. It is not zero, and this dataset never turns
it into zero.

`metadata/field_coverage.parquet` records the first date every numeric field is
populated, so a reader can tell "the Treasury had not started publishing this"
apart from "nobody bid". Nowhere in this dataset does an absent field become a
zero.

## The methodology changed, and the rates are not recomputed

The par yield curve is the output of a procedure, and the procedure changed:
the **monotone convex** method replaced the **quasi-cubic hermite spline** as of
**6 December 2021**, which the Treasury states on its methodology page.

A rate from 2015 and a rate from 2022 are therefore not the same kind of
number. Neither is recomputed under the other's method — the published values
stand as published. `methodology_id` on every nominal curve row says which
procedure produced it, and `metadata/yield_curve_methodology.parquet` says what
each one was, with the Treasury's own description and the source URL.

## Maturities come and go, and nothing is filled in

The 20-year bond returned in May 2020 after seventeen years away. The 4-month
bill was added in October 2022. The set of maturities on the curve is not
constant, and this dataset stores the curve in long form so that a maturity the
Treasury did not publish is an **absent row**, not a null that looks like
missing data and invites interpolation.

| Maturity | First published | |
|---|---|---|
| 3M, 6M, 1Y, 2Y, 3Y, 5Y, 7Y, 10Y | 2 January 1990 | the original set |
| 20Y | 1 October 1993 | |
| **30Y** | 2 January 1990 | **absent 15 Feb 2002 – 9 Feb 2006**, four years |
| 1M | 31 July 2001 | |
| 2M | 16 October 2018 | |
| 4M | 19 October 2022 | |
| 1.5M | 18 February 2025 | |

The 30-year gap is the one that catches people: 1 455 days with no long bond on
the curve, in the middle of a series that otherwise runs unbroken. Here those
days simply have no 30-year row.

Nothing is interpolated. A curve published without a 20-year point is published
here without one.

## Using it

```python
import polars as pl

pit = pl.read_parquet("data/pit/*.parquet")

# The 10-year constant maturity, as it was actually knowable
ten = pit.filter(pl.col("entity_id") == "UST_CMT_10Y").select(
    "event_date", "knowledge_date", "actual", "change"
)

# Every 10-year note auction, at the minute its result was released
auctions = pit.filter(pl.col("entity_id") == "UST_AUCTION_10Y_BID_TO_COVER")

# Everything a strategy could have known at 4pm Eastern on a given day
known = pit.filter(
    pl.col("knowledge_date") <= pl.lit("2026-09-10T20:00:00").str.to_datetime(time_zone="UTC")
)
```

That last filter is the one that matters. Run it against 4:00 p.m. Eastern and
the day's auction results are there — they came out at 1:02 p.m. — but the
day's yield curve is correctly absent, because it was not on the Treasury's site
until six.

## What is in it

| Config | Rows | What one row is |
|---|---|---|
| `pit` | 268 960 | one number becoming public — 1 287 series, plus a Delta table |
| `auction_results` | 11 108 | one completed auction, at the minute its result was released |
| `auction_calendar` | 11 114 | one auctioned or announced security, dated from its announcement |
| `auction_announcements` | 11 114 | one announcement, with its competitive and noncompetitive closing times |
| `nominal_yield_curve` | 113 836 | one maturity of one day's par yield curve, 1990→ |
| `real_yield_curve` | 34 141 | one maturity of one day's TIPS par real curve, 2003→ |
| `bill_rates` | 26 453 | one bill maturity of one day, on both quote conventions |
| `curve_features` | 9 180 | derived slopes and one spread, per trading day |

Auctions split 7 396 bills, 1 967 notes, 934 cash management bills, 394 bonds,
269 TIPS and 154 floating rate notes. Six are announced but not yet held.

`pit` keys auction metrics by **term** rather than by CUSIP, so
`UST_AUCTION_10Y_BID_TO_COVER` runs across issues instead of stopping when one
bond is auctioned. Curve points are `UST_CMT_10Y`, `UST_REAL_CMT_10Y`,
`UST_BILL_13W_CE`; a bill becomes two series because it is quoted two ways.

One limitation worth knowing: in 1984-85 the Treasury occasionally auctioned two
securities of the same odd term on the same day, and with no artifact to give
them different minutes, 12 `pit` rows share an entity, a date and an instant.
`record_id` keeps them apart, and the gate reports them rather than hiding them.

## Derived, and labelled as such

`curve_features` is arithmetic on two numbers that were public at the same
instant, so it inherits that instant. Where a leg is missing — no 20-year point
between 2002 and 2020, no real curve before 2003 — the feature is null rather
than interpolated.

One caution on `nominal_10y_minus_real_10y_bp`: it is a spread between two
official curves published for the same day. It is **not** a market breakeven.
Both legs are par yields struck from indicative quotations, and neither is a
traded inflation instrument.

In `auction_results`, `dealer_accepted_pct`, `direct_accepted_pct`,
`indirect_accepted_pct`, `noncompetitive_accepted_pct` and
`tendered_to_offering` are computed only from numbers in the same result, and
are null wherever either side is absent. In `pit` they carry
`value_method = "derived"`; everything else is `"reported"`.

## Provenance

Every row carries `source_url` and, where an artifact was read, `raw_sha256` —
the digest of the exact bytes the Treasury served. Nothing here comes from FRED,
a vendor, or a mirror: a secondary copy of a Treasury rate cannot carry the one
thing this dataset exists to record.

Source: the United States Department of the Treasury, a US Government work in
the public domain. The Department does not endorse, certify or verify this
dataset. The additions here — the release instants, the long-form curves, the
validation — are Apache-2.0.

## Rebuilding it

The first build reads 6 229 auction artifacts and 185 rate files, and takes
about thirty-five minutes. Every run after that reuses them — a finished
auction's result cannot change, and neither can a year of rates that is over —
and finishes in **under three seconds**, having asked the Treasury for seven
documents: the auction query, the announced list, and the current year of each
of the five rate feeds.

```bash
python -m recipe.cli build            # incremental
python -m recipe.cli build --rebuild  # read everything again; what a parser change needs
```

The two produce identical tables; `tests/test_auctions.py` covers which rows
are eligible for reuse and why a date-precision row is not.

## Related

[us-economic-events](https://huggingface.co/datasets/ZipLime/us-economic-events) ·
[fomc-events](https://huggingface.co/datasets/ZipLime/fomc-events) ·
[commitments-of-traders](https://huggingface.co/datasets/ZipLime/commitments-of-traders)